1 /*****************************************************************************
3 # Copyright 2019 AT&T Intellectual Property *
4 # Copyright 2019 Nokia *
5 # Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved. *
7 # Licensed under the Apache License, Version 2.0 (the "License"); *
8 # you may not use this file except in compliance with the License. *
9 # You may obtain a copy of the License at *
11 # http://www.apache.org/licenses/LICENSE-2.0 *
13 # Unless required by applicable law or agreed to in writing, software *
14 # distributed under the License is distributed on an "AS IS" BASIS, *
15 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
16 # See the License for the specific language governing permissions and *
17 # limitations under the License. *
19 ******************************************************************************/
30 #include "encode_e2apv1.hpp"
33 #include "E2SM-KPM-RANfunction-Description.h"
35 #include "e2ap_asn1c_codec.h"
36 #include "GlobalE2node-ID.h"
37 #include "GlobalE2node-gNB-ID.h"
38 #include "GlobalgNB-ID.h"
39 #include "OCTET_STRING.h"
40 #include "asn_application.h"
41 #include "GNB-ID-Choice.h"
42 #include "ProtocolIE-Field.h"
43 #include "E2setupRequest.h"
44 #include "RICaction-ToBeSetup-Item.h"
45 #include "RICactions-ToBeSetup-List.h"
46 #include "RICeventTriggerDefinition.h"
47 #include "RICsubscriptionRequest.h"
48 #include "RICsubscriptionResponse.h"
49 #include "ProtocolIE-SingleContainer.h"
50 #include "RANfunctions-List.h"
51 #include "RICindication.h"
52 #include "RICsubsequentActionType.h"
53 #include "RICsubsequentAction.h"
54 #include "RICtimeToWait.h"
58 void generate_e2apv1_service_update(E2AP_PDU_t *e2ap_pdu) {
60 char* ran_function_op_type = getenv("RAN_FUNCTION_OP_TYPE");
61 LOG_D("Ran funciton : %s", ran_function_op_type);
63 if (ran_function_op_type != NULL)
65 if (strcmp(ran_function_op_type, "ADD") == 0)
67 prID = ProtocolIE_ID_id_RANfunctionsAdded;
69 else if (strcmp(ran_function_op_type, "DELETE"))
71 prID = ProtocolIE_ID_id_RANfunctionsDeleted;
76 prID = ProtocolIE_ID_id_RANfunctionsModified;
79 auto *itemIes = (RANfunction_ItemIEs_t *)calloc(1, sizeof(RANfunction_ItemIEs_t));
80 itemIes->id = ProtocolIE_ID_id_RANfunction_Item;
81 itemIes->criticality = Criticality_reject;
82 itemIes->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
83 itemIes->value.choice.RANfunction_Item.ranFunctionID = 1;
85 E2SM_KPM_RANfunction_Description_t *ranfunc_desc =
86 (E2SM_KPM_RANfunction_Description_t*)calloc(1,sizeof(E2SM_KPM_RANfunction_Description_t));
87 encode_kpm_function_description(ranfunc_desc);
89 uint8_t e2smbuffer[8192];
90 size_t e2smbuffer_size = 8192;
92 asn_codec_ctx_t *opt_cod;
95 asn_encode_to_buffer(opt_cod,
96 ATS_ALIGNED_BASIC_PER,
97 &asn_DEF_E2SM_KPM_RANfunction_Description,
98 ranfunc_desc, e2smbuffer, e2smbuffer_size);
100 fprintf(stderr, "er encded is %d\n", er.encoded);
101 fprintf(stderr, "after encoding message\n");
103 OCTET_STRING_t *ranfuncdesc_str = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
104 ranfuncdesc_str->buf = (uint8_t*)calloc(1,er.encoded);
105 ranfuncdesc_str->size = er.encoded;
106 memcpy(ranfuncdesc_str->buf, e2smbuffer, er.encoded);
110 itemIes->value.choice.RANfunction_Item.ranFunctionDefinition = *ranfuncdesc_str;
111 itemIes->value.choice.RANfunction_Item.ranFunctionRevision = (long)3;
114 RICserviceUpdate_IEs_t *e2serviceUpdateList = (RICserviceUpdate_IEs_t *)calloc(1, sizeof(RICserviceUpdate_IEs_t));
115 e2serviceUpdateList->id = prID; /// is it correct ???
116 e2serviceUpdateList->criticality = Criticality_reject;
117 e2serviceUpdateList->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
118 ASN_SEQUENCE_ADD(&e2serviceUpdateList->value.choice.RANfunctions_List.list, itemIes);
120 RICserviceUpdate_t *ricServiceUpdate = (RICserviceUpdate_t *)calloc(1, sizeof(RICserviceUpdate_t));
121 ASN_SEQUENCE_ADD(&ricServiceUpdate->protocolIEs.list, e2serviceUpdateList);
123 InitiatingMessage_t *initiatingMessage = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t));
124 initiatingMessage->criticality = Criticality_reject;
125 initiatingMessage->procedureCode = ProcedureCode_id_RICserviceUpdate;
126 initiatingMessage->value.present = InitiatingMessage__value_PR_RICserviceUpdate;
127 initiatingMessage->value.choice.RICserviceUpdate = *ricServiceUpdate;
129 E2AP_PDU_PR pres6 = E2AP_PDU_PR_initiatingMessage;
130 e2ap_pdu->present = pres6;
131 e2ap_pdu->choice.initiatingMessage = initiatingMessage;
134 long get_function_id_from_subscription(E2AP_PDU_t *e2ap_pdu) {
136 RICsubscriptionRequest_t orig_req =
137 e2ap_pdu->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
139 RICsubscriptionResponse_IEs_t *ricreqid =
140 (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
142 int count = orig_req.protocolIEs.list.count;
143 int size = orig_req.protocolIEs.list.size;
145 RICsubscriptionRequest_IEs_t **ies = (RICsubscriptionRequest_IEs_t**)orig_req.protocolIEs.list.array;
147 fprintf(stderr, "count%d\n", count);
148 fprintf(stderr, "size%d\n", size);
150 RICsubscriptionRequest_IEs__value_PR pres;
154 for (int i=0; i < count; i++) {
155 RICsubscriptionRequest_IEs_t *next_ie = ies[i];
156 pres = next_ie->value.present;
158 fprintf(stderr, "next present value %d\n", pres);
160 if (pres == RICsubscriptionRequest_IEs__value_PR_RANfunctionID) {
161 func_id = next_ie->value.choice.RANfunctionID;
170 void generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu, std::vector<ran_func_info> all_funcs) {
171 // long ranFunctionId, uint8_t *ranFuncDescEncoded, int ranFuncLength) {
173 // uint8_t *buf = (uint8_t *)"gnb1"
175 BIT_STRING_t *gnb_bstring = (BIT_STRING_t*)calloc(1, sizeof(BIT_STRING_t));;
176 gnb_bstring->buf = (uint8_t*)calloc(1,4);
177 gnb_bstring->size = 4;
178 gnb_bstring->buf[0] = 0xB5;
179 gnb_bstring->buf[1] = 0xC6;
180 gnb_bstring->buf[2] = 0x77;
181 gnb_bstring->buf[3] = 0x88;
183 gnb_bstring->bits_unused = 3;
185 uint8_t *buf2 = (uint8_t *)"747";
186 OCTET_STRING_t *plmn = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
187 plmn->buf = (uint8_t*)calloc(1,3);
188 memcpy(plmn->buf, buf2, 3);
191 GNB_ID_Choice_t *gnbchoice = (GNB_ID_Choice_t*)calloc(1,sizeof(GNB_ID_Choice_t));
192 GNB_ID_Choice_PR pres2 = GNB_ID_Choice_PR_gnb_ID;
193 gnbchoice->present = pres2;
194 gnbchoice->choice.gnb_ID = *gnb_bstring;
196 GlobalgNB_ID_t *gnb = (GlobalgNB_ID_t*)calloc(1, sizeof(GlobalgNB_ID_t));
197 gnb->plmn_id = *plmn;
198 gnb->gnb_id = *gnbchoice;
200 GlobalE2node_gNB_ID_t *e2gnb = (GlobalE2node_gNB_ID_t*)calloc(1, sizeof(GlobalE2node_gNB_ID_t));
201 e2gnb->global_gNB_ID = *gnb;
203 GlobalE2node_ID_t *globale2nodeid = (GlobalE2node_ID_t*)calloc(1, sizeof(GlobalE2node_ID_t));
204 GlobalE2node_ID_PR pres;
205 pres = GlobalE2node_ID_PR_gNB;
206 globale2nodeid->present = pres;
207 globale2nodeid->choice.gNB = e2gnb;
209 E2setupRequestIEs_t *e2setuprid = (E2setupRequestIEs_t*)calloc(1, sizeof(E2setupRequestIEs_t));
210 E2setupRequestIEs__value_PR pres3;
211 pres3 = E2setupRequestIEs__value_PR_GlobalE2node_ID;
213 e2setuprid->criticality = 0;
214 e2setuprid->value.choice.GlobalE2node_ID = *globale2nodeid;
215 e2setuprid->value.present = pres3;
218 auto *ranFlistIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t));
219 ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, ranFlistIEs);
220 ranFlistIEs->criticality = 0;
221 ranFlistIEs->id = ProtocolIE_ID_id_RANfunctionsAdded;
222 ranFlistIEs->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
225 for (int i = 0; i < all_funcs.size(); i++) {
227 ran_func_info nextRanFunc = all_funcs.at(i);
228 long nextRanFuncId = nextRanFunc.ranFunctionId;
229 OCTET_STRING_t *nextRanFuncDesc = nextRanFunc.ranFunctionDesc;
230 long nextRanFuncRev = nextRanFunc.ranFunctionRev;
232 auto *itemIes = (RANfunction_ItemIEs_t *)calloc(1, sizeof(RANfunction_ItemIEs_t));
233 itemIes->id = ProtocolIE_ID_id_RANfunction_Item;
234 itemIes->criticality = Criticality_reject;
235 itemIes->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
236 itemIes->value.choice.RANfunction_Item.ranFunctionID = nextRanFuncId;
238 int ranFuncLength = strlen((char*)nextRanFuncDesc);
240 itemIes->value.choice.RANfunction_Item.ranFunctionDefinition = *nextRanFuncDesc;
241 itemIes->value.choice.RANfunction_Item.ranFunctionRevision = nextRanFuncRev;
243 ASN_SEQUENCE_ADD(&ranFlistIEs->value.choice.RANfunctions_List.list, itemIes);
247 E2setupRequest_t *e2setupreq = (E2setupRequest_t*)calloc(1, sizeof(E2setupRequest_t));
248 ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, e2setuprid);
249 ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, ranFlistIEs);
251 InitiatingMessage__value_PR pres4;
252 pres4 = InitiatingMessage__value_PR_E2setupRequest;
253 InitiatingMessage_t *initmsg = (InitiatingMessage_t*)calloc(1, sizeof(InitiatingMessage_t));
255 initmsg->procedureCode = ProcedureCode_id_E2setup;
256 initmsg->criticality = Criticality_reject;
257 initmsg->value.present = pres4;
258 initmsg->value.choice.E2setupRequest = *e2setupreq;
261 pres5 = E2AP_PDU_PR_initiatingMessage;
264 e2ap_pdu->present = pres5;
265 e2ap_pdu->choice.initiatingMessage = initmsg;
269 void generate_e2apv1_setup_request(E2AP_PDU_t *e2ap_pdu) {
271 // uint8_t *buf = (uint8_t *)"gnb1"
273 BIT_STRING_t *gnb_bstring = (BIT_STRING_t*)calloc(1, sizeof(BIT_STRING_t));;
274 gnb_bstring->buf = (uint8_t*)calloc(1,4);
275 gnb_bstring->size = 4;
276 gnb_bstring->buf[0] = 0xB5;
277 gnb_bstring->buf[1] = 0xC6;
278 gnb_bstring->buf[2] = 0x77;
279 gnb_bstring->buf[3] = 0x88;
281 gnb_bstring->bits_unused = 3;
283 uint8_t *buf2 = (uint8_t *)"747";
284 OCTET_STRING_t *plmn = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
285 plmn->buf = (uint8_t*)calloc(1,3);
286 memcpy(plmn->buf, buf2, 3);
289 GNB_ID_Choice_t *gnbchoice = (GNB_ID_Choice_t*)calloc(1,sizeof(GNB_ID_Choice_t));
290 GNB_ID_Choice_PR pres2 = GNB_ID_Choice_PR_gnb_ID;
291 gnbchoice->present = pres2;
292 gnbchoice->choice.gnb_ID = *gnb_bstring;
294 GlobalgNB_ID_t *gnb = (GlobalgNB_ID_t*)calloc(1, sizeof(GlobalgNB_ID_t));
295 gnb->plmn_id = *plmn;
296 gnb->gnb_id = *gnbchoice;
298 GlobalE2node_gNB_ID_t *e2gnb = (GlobalE2node_gNB_ID_t*)calloc(1, sizeof(GlobalE2node_gNB_ID_t));
299 e2gnb->global_gNB_ID = *gnb;
301 GlobalE2node_ID_t *globale2nodeid = (GlobalE2node_ID_t*)calloc(1, sizeof(GlobalE2node_ID_t));
302 GlobalE2node_ID_PR pres;
303 pres = GlobalE2node_ID_PR_gNB;
304 globale2nodeid->present = pres;
305 globale2nodeid->choice.gNB = e2gnb;
307 E2setupRequestIEs_t *e2setuprid = (E2setupRequestIEs_t*)calloc(1, sizeof(E2setupRequestIEs_t));
308 E2setupRequestIEs__value_PR pres3;
309 pres3 = E2setupRequestIEs__value_PR_GlobalE2node_ID;
311 e2setuprid->criticality = 0;
312 e2setuprid->value.choice.GlobalE2node_ID = *globale2nodeid;
313 e2setuprid->value.present = pres3;
316 auto *ranFlistIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t));
317 ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, ranFlistIEs);
318 ranFlistIEs->criticality = 0;
319 ranFlistIEs->id = ProtocolIE_ID_id_RANfunctionsAdded;
320 ranFlistIEs->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
322 auto *itemIes = (RANfunction_ItemIEs_t *)calloc(1, sizeof(RANfunction_ItemIEs_t));
323 itemIes->id = ProtocolIE_ID_id_RANfunction_Item;
324 itemIes->criticality = Criticality_reject;
325 itemIes->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
326 itemIes->value.choice.RANfunction_Item.ranFunctionID = 1;
328 E2SM_KPM_RANfunction_Description_t *ranfunc_desc =
329 (E2SM_KPM_RANfunction_Description_t*)calloc(1,sizeof(E2SM_KPM_RANfunction_Description_t));
330 encode_kpm_function_description(ranfunc_desc);
332 uint8_t e2smbuffer[8192];
333 size_t e2smbuffer_size = 8192;
335 asn_codec_ctx_t *opt_cod;
338 asn_encode_to_buffer(opt_cod,
339 ATS_ALIGNED_BASIC_PER,
340 &asn_DEF_E2SM_KPM_RANfunction_Description,
341 ranfunc_desc, e2smbuffer, e2smbuffer_size);
343 fprintf(stderr, "er encded is %d\n", er.encoded);
344 fprintf(stderr, "after encoding message\n");
346 OCTET_STRING_t *ranfuncdesc_str = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
347 ranfuncdesc_str->buf = (uint8_t*)calloc(1,er.encoded);
348 ranfuncdesc_str->size = er.encoded;
349 memcpy(ranfuncdesc_str->buf, e2smbuffer, er.encoded);
352 itemIes->value.choice.RANfunction_Item.ranFunctionDefinition = *ranfuncdesc_str;
353 itemIes->value.choice.RANfunction_Item.ranFunctionRevision = (long)2;
355 ASN_SEQUENCE_ADD(&ranFlistIEs->value.choice.RANfunctions_List.list, itemIes);
357 E2setupRequest_t *e2setupreq = (E2setupRequest_t*)calloc(1, sizeof(E2setupRequest_t));
358 ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, e2setuprid);
359 ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, ranFlistIEs);
361 InitiatingMessage__value_PR pres4;
362 pres4 = InitiatingMessage__value_PR_E2setupRequest;
363 InitiatingMessage_t *initmsg = (InitiatingMessage_t*)calloc(1, sizeof(InitiatingMessage_t));
365 initmsg->procedureCode = ProcedureCode_id_E2setup;
366 initmsg->criticality = Criticality_reject;
367 initmsg->value.present = pres4;
368 initmsg->value.choice.E2setupRequest = *e2setupreq;
371 pres5 = E2AP_PDU_PR_initiatingMessage;
374 e2ap_pdu->present = pres5;
375 e2ap_pdu->choice.initiatingMessage = initmsg;
380 void generate_e2apv1_setup_response(E2AP_PDU_t *e2ap_pdu) {
382 E2setupResponseIEs *resp_ies1 = (E2setupResponseIEs_t*)calloc(1, sizeof(E2setupResponseIEs_t));
383 E2setupResponseIEs *resp_ies2 = (E2setupResponseIEs_t*)calloc(1, sizeof(E2setupResponseIEs_t));
384 E2setupResponseIEs *resp_ies3 = (E2setupResponseIEs_t*)calloc(1, sizeof(E2setupResponseIEs_t));
386 uint8_t *buf = (uint8_t *)"gnb1";
388 BIT_STRING_t *ricid_bstring = (BIT_STRING_t*)calloc(1,sizeof(BIT_STRING_t));
389 ricid_bstring->buf = buf;
390 ricid_bstring->size = 4;
391 ricid_bstring->bits_unused = 0;
393 uint8_t *buf2 = (uint8_t *)"plmn3";
394 OCTET_STRING_t *plmn = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
398 GlobalRIC_ID_t *globalricid = (GlobalRIC_ID_t*)calloc(1,sizeof(GlobalRIC_ID_t));
399 globalricid->pLMN_Identity = *plmn;
400 globalricid->ric_ID = *ricid_bstring;
402 E2setupResponseIEs__value_PR pres1;
403 pres1 = E2setupResponseIEs__value_PR_GlobalRIC_ID;
405 resp_ies1->id = ProtocolIE_ID_id_GlobalRIC_ID;
406 resp_ies1->criticality = 0;
407 resp_ies1->value.present = pres1;
408 resp_ies1->value.choice.GlobalRIC_ID = *globalricid;
410 E2setupResponse_t *e2setupresp = (E2setupResponse_t*)calloc(1,sizeof(E2setupResponse_t));
411 int ret = ASN_SEQUENCE_ADD(&e2setupresp->protocolIEs.list, resp_ies1);
414 SuccessfulOutcome__value_PR pres;
415 pres = SuccessfulOutcome__value_PR_E2setupResponse;
416 SuccessfulOutcome_t *successoutcome = (SuccessfulOutcome_t*)calloc(1, sizeof(SuccessfulOutcome_t));
417 successoutcome->procedureCode = 1;
418 successoutcome->criticality = 0;
419 successoutcome->value.present = pres;
420 successoutcome->value.choice.E2setupResponse = *e2setupresp;
422 E2AP_PDU_PR pres5 = E2AP_PDU_PR_successfulOutcome;
424 e2ap_pdu->present = pres5;
425 e2ap_pdu->choice.successfulOutcome = successoutcome;
430 void generate_e2apv1_subscription_request(E2AP_PDU *e2ap_pdu) {
432 fprintf(stderr, "in sub 1\n");
433 RICsubscriptionRequest_IEs_t *ricreqid = (RICsubscriptionRequest_IEs_t*)calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
434 fprintf(stderr, "in sub 2\n");
435 ASN_STRUCT_RESET(asn_DEF_RICsubscriptionRequest_IEs, ricreqid);
436 fprintf(stderr, "in sub 3\n");
437 auto *ricsubrid = (RICsubscriptionRequest_IEs_t*)calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
438 fprintf(stderr, "in sub 4\n");
439 ASN_STRUCT_RESET(asn_DEF_RICsubscriptionRequest_IEs, ricsubrid);
441 fprintf(stderr, "in generate sub\n");
442 uint8_t *buf2 = (uint8_t *)"SubscriptionTriggers";
443 fprintf(stderr, "in gen sub 1\n");
444 OCTET_STRING_t *triggerdef = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
445 triggerdef->buf = (uint8_t *)calloc(1,20);
446 triggerdef->size = 20;
447 memcpy(triggerdef->buf, buf2, triggerdef->size);
450 fprintf(stderr, "sub1\n");
451 ProtocolIE_ID_t proto_id= ProtocolIE_ID_id_RICaction_ToBeSetup_Item;
453 RICaction_ToBeSetup_ItemIEs__value_PR pres6;
454 pres6 = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
458 uint8_t *buf5 = (uint8_t *)"ActionDef";
460 OCTET_STRING_t *actdef = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
461 actdef->buf = (uint8_t *)calloc(1,9);
463 memcpy(triggerdef->buf, buf5, 9);
465 auto *sa = (RICsubsequentAction_t *) calloc(1, sizeof(RICsubsequentAction_t));
466 ASN_STRUCT_RESET(asn_DEF_RICsubsequentAction, sa);
468 sa->ricTimeToWait = RICtimeToWait_w500ms;
469 sa->ricSubsequentActionType = RICsubsequentActionType_continue;
473 RICaction_ToBeSetup_ItemIEs_t *action_item_ies = (RICaction_ToBeSetup_ItemIEs_t *)calloc(1, sizeof(RICaction_ToBeSetup_Item_t));
474 action_item_ies->id = proto_id;
475 action_item_ies->criticality = 0;
477 action_item_ies->value.present = pres6;
478 action_item_ies->value.choice.RICaction_ToBeSetup_Item.ricActionID = 5;
479 action_item_ies->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report;
480 action_item_ies->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition = actdef;
481 action_item_ies->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction = sa;
487 RICsubscriptionRequest_IEs__value_PR pres3;
489 pres3 = RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
490 ricsubrid->id = ProtocolIE_ID_id_RICsubscriptionDetails;
493 ricsubrid->criticality = 0;
494 ricsubrid->value.present = pres3;
497 ricsubrid->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition = *triggerdef;
500 ASN_SEQUENCE_ADD(&ricsubrid->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.list, action_item_ies);
505 ricreqid->id = ProtocolIE_ID_id_RICrequestID;
506 ricreqid->criticality = 0;
507 ricreqid->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
508 ricreqid->value.choice.RICrequestID.ricRequestorID = 22;
509 ricreqid->value.choice.RICrequestID.ricInstanceID = 6;
511 RICsubscriptionRequest_t *ricsubreq = (RICsubscriptionRequest_t*)calloc(1, sizeof(RICsubscriptionRequest_t));
513 ASN_SEQUENCE_ADD(&ricsubreq->protocolIEs.list,ricreqid);
514 ASN_SEQUENCE_ADD(&ricsubreq->protocolIEs.list,ricsubrid);
518 InitiatingMessage__value_PR pres4;
519 pres4 = InitiatingMessage__value_PR_RICsubscriptionRequest;
520 InitiatingMessage_t *initmsg = (InitiatingMessage_t*)calloc(1, sizeof(InitiatingMessage_t));
521 initmsg->procedureCode = ProcedureCode_id_RICsubscription;
522 initmsg->criticality = Criticality_reject;
523 initmsg->value.present = pres4;
524 initmsg->value.choice.RICsubscriptionRequest = *ricsubreq;
527 pres5 = E2AP_PDU_PR_initiatingMessage;
530 e2ap_pdu->present = pres5;
531 e2ap_pdu->choice.initiatingMessage = initmsg;
533 char *error_buf = (char*)calloc(300, sizeof(char));;
536 asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
537 printf("error length %d\n", errlen);
538 printf("error buf %s\n", error_buf);
543 void generate_e2apv1_subscription_response_success(E2AP_PDU *e2ap_pdu, long reqActionIdsAccepted[],
544 long reqActionIdsRejected[], int accept_size, int reject_size,
545 long reqRequestorId, long reqInstanceId) {
547 RICsubscriptionResponse_IEs_t *respricreqid =
548 (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
550 respricreqid->id = ProtocolIE_ID_id_RICrequestID;
551 respricreqid->criticality = 0;
552 respricreqid->value.present = RICsubscriptionResponse_IEs__value_PR_RICrequestID;
553 respricreqid->value.choice.RICrequestID.ricRequestorID = reqRequestorId;
555 respricreqid->value.choice.RICrequestID.ricInstanceID = reqInstanceId;
558 RICsubscriptionResponse_IEs_t *ricactionadmitted =
559 (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
560 ricactionadmitted->id = ProtocolIE_ID_id_RICactions_Admitted;
561 ricactionadmitted->criticality = 0;
562 ricactionadmitted->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
564 RICaction_Admitted_List_t* admlist =
565 (RICaction_Admitted_List_t*)calloc(1,sizeof(RICaction_Admitted_List_t));
566 ricactionadmitted->value.choice.RICaction_Admitted_List = *admlist;
569 int numAccept = accept_size;
570 int numReject = reject_size;
574 for (int i=0; i < numAccept ; i++) {
575 fprintf(stderr, "in for loop i = %d\n", i);
577 long aid = reqActionIdsAccepted[i];
579 RICaction_Admitted_ItemIEs_t *admitie = (RICaction_Admitted_ItemIEs_t*)calloc(1,sizeof(RICaction_Admitted_ItemIEs_t));
580 admitie->id = ProtocolIE_ID_id_RICaction_Admitted_Item;
581 admitie->criticality = 0;
582 admitie->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
583 admitie->value.choice.RICaction_Admitted_Item.ricActionID = aid;
585 ASN_SEQUENCE_ADD(&ricactionadmitted->value.choice.RICaction_Admitted_List.list, admitie);
589 RICsubscriptionResponse_t *ricsubresp = (RICsubscriptionResponse_t*)calloc(1,sizeof(RICsubscriptionResponse_t));
590 ASN_SEQUENCE_ADD(&ricsubresp->protocolIEs.list, respricreqid);
591 ASN_SEQUENCE_ADD(&ricsubresp->protocolIEs.list, ricactionadmitted);
596 RICsubscriptionResponse_IEs_t *ricactionrejected =
597 (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
598 ricactionrejected->id = ProtocolIE_ID_id_RICactions_NotAdmitted;
599 ricactionrejected->criticality = 0;
600 ricactionrejected->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
602 RICaction_NotAdmitted_List_t* rejectlist =
603 (RICaction_NotAdmitted_List_t*)calloc(1,sizeof(RICaction_NotAdmitted_List_t));
604 ricactionadmitted->value.choice.RICaction_NotAdmitted_List = *rejectlist;
606 for (int i=0; i < numReject; i++) {
607 fprintf(stderr, "in for loop i = %d\n", i);
609 long aid = reqActionIdsRejected[i];
611 RICaction_NotAdmitted_ItemIEs_t *noadmitie = (RICaction_NotAdmitted_ItemIEs_t*)calloc(1,sizeof(RICaction_NotAdmitted_ItemIEs_t));
612 noadmitie->id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item;
613 noadmitie->criticality = 0;
614 noadmitie->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;
615 noadmitie->value.choice.RICaction_NotAdmitted_Item.ricActionID = aid;
617 ASN_SEQUENCE_ADD(&ricactionrejected->value.choice.RICaction_NotAdmitted_List.list, noadmitie);
618 ASN_SEQUENCE_ADD(&ricsubresp->protocolIEs.list, ricactionrejected);
623 SuccessfulOutcome__value_PR pres2;
624 pres2 = SuccessfulOutcome__value_PR_RICsubscriptionResponse;
625 SuccessfulOutcome_t *successoutcome = (SuccessfulOutcome_t*)calloc(1, sizeof(SuccessfulOutcome_t));
626 successoutcome->procedureCode = ProcedureCode_id_RICsubscription;
627 successoutcome->criticality = 0;
628 successoutcome->value.present = pres2;
629 successoutcome->value.choice.RICsubscriptionResponse = *ricsubresp;
631 E2AP_PDU_PR pres5 = E2AP_PDU_PR_successfulOutcome;
633 e2ap_pdu->present = pres5;
634 e2ap_pdu->choice.successfulOutcome = successoutcome;
636 char *error_buf = (char*)calloc(300, sizeof(char));
639 asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
640 printf("error length %d\n", errlen);
641 printf("error buf %s\n", error_buf);
646 void generate_e2apv1_subscription_response(E2AP_PDU *e2ap_pdu, E2AP_PDU *sub_req_pdu) {
648 //Gather details of the request
650 RICsubscriptionRequest_t orig_req =
651 sub_req_pdu->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
653 RICsubscriptionResponse_IEs_t *ricreqid =
654 (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
656 int count = orig_req.protocolIEs.list.count;
657 int size = orig_req.protocolIEs.list.size;
659 RICsubscriptionRequest_IEs_t **ies = (RICsubscriptionRequest_IEs_t**)orig_req.protocolIEs.list.array;
661 fprintf(stderr, "count%d\n", count);
662 fprintf(stderr, "size%d\n", size);
664 RICsubscriptionRequest_IEs__value_PR pres;
666 long responseRequestorId;
667 long responseInstanceId;
668 long responseActionId;
670 std::vector<long> actionIds;
672 for (int i=0; i < count; i++) {
673 RICsubscriptionRequest_IEs_t *next_ie = ies[i];
674 pres = next_ie->value.present;
676 fprintf(stderr, "next present value %d\n", pres);
679 case RICsubscriptionRequest_IEs__value_PR_RICrequestID:
681 RICrequestID_t reqId = next_ie->value.choice.RICrequestID;
682 long requestorId = reqId.ricRequestorID;
683 long instanceId = reqId.ricInstanceID;
684 fprintf(stderr, "requestorId %d\n", requestorId);
685 fprintf(stderr, "instanceId %d\n", instanceId);
686 responseRequestorId = requestorId;
687 responseInstanceId = instanceId;
691 case RICsubscriptionRequest_IEs__value_PR_RANfunctionID:
693 case RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails:
695 RICsubscriptionDetails_t subDetails = next_ie->value.choice.RICsubscriptionDetails;
696 RICeventTriggerDefinition_t triggerDef = subDetails.ricEventTriggerDefinition;
697 RICactions_ToBeSetup_List_t actionList = subDetails.ricAction_ToBeSetup_List;
699 int actionCount = actionList.list.count;
700 fprintf(stderr, "action count%d\n", actionCount);
702 auto **item_array = actionList.list.array;
704 for (int i=0; i < actionCount; i++) {
705 //RICaction_ToBeSetup_Item_t
706 auto *next_item = item_array[i];
707 RICactionID_t actionId = ((RICaction_ToBeSetup_ItemIEs*)next_item)->value.choice.RICaction_ToBeSetup_Item.ricActionID;
708 fprintf(stderr, "Next Action ID %ld\n", actionId);
709 responseActionId = actionId;
710 actionIds.push_back(responseActionId);
719 fprintf(stderr, "After Processing Subscription Request\n");
721 fprintf(stderr, "requestorId %d\n", responseRequestorId);
722 fprintf(stderr, "instanceId %d\n", responseInstanceId);
725 for (int i=0; i < actionIds.size(); i++) {
726 fprintf(stderr, "Action ID %d %ld\n", i, actionIds.at(i));
731 RICsubscriptionResponse_IEs_t *respricreqid =
732 (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
734 respricreqid->id = ProtocolIE_ID_id_RICrequestID;
735 respricreqid->criticality = 0;
736 respricreqid->value.present = RICsubscriptionResponse_IEs__value_PR_RICrequestID;
737 respricreqid->value.choice.RICrequestID.ricRequestorID = responseRequestorId;
739 respricreqid->value.choice.RICrequestID.ricInstanceID = responseInstanceId;
742 RICsubscriptionResponse_IEs_t *ricactionadmitted =
743 (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
744 ricactionadmitted->id = ProtocolIE_ID_id_RICactions_Admitted;
745 ricactionadmitted->criticality = 0;
746 ricactionadmitted->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
748 RICaction_Admitted_List_t* admlist =
749 (RICaction_Admitted_List_t*)calloc(1,sizeof(RICaction_Admitted_List_t));
750 ricactionadmitted->value.choice.RICaction_Admitted_List = *admlist;
752 for (int i=0; i < actionIds.size(); i++) {
753 fprintf(stderr, "in for loop i = %d\n", i);
755 long aid = actionIds.at(i);
757 RICaction_Admitted_ItemIEs_t *admitie = (RICaction_Admitted_ItemIEs_t*)calloc(1,sizeof(RICaction_Admitted_ItemIEs_t));
758 admitie->id = ProtocolIE_ID_id_RICaction_Admitted_Item;
759 admitie->criticality = 0;
760 admitie->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
761 admitie->value.choice.RICaction_Admitted_Item.ricActionID = aid;
763 ASN_SEQUENCE_ADD(&ricactionadmitted->value.choice.RICaction_Admitted_List.list, admitie);
768 RICsubscriptionResponse_t *ricsubresp = (RICsubscriptionResponse_t*)calloc(1,sizeof(RICsubscriptionResponse_t));
770 ASN_SEQUENCE_ADD(&ricsubresp->protocolIEs.list, respricreqid);
771 ASN_SEQUENCE_ADD(&ricsubresp->protocolIEs.list, ricactionadmitted);
774 SuccessfulOutcome__value_PR pres2;
775 pres2 = SuccessfulOutcome__value_PR_RICsubscriptionResponse;
776 SuccessfulOutcome_t *successoutcome = (SuccessfulOutcome_t*)calloc(1, sizeof(SuccessfulOutcome_t));
777 successoutcome->procedureCode = ProcedureCode_id_RICsubscription;
778 successoutcome->criticality = 0;
779 successoutcome->value.present = pres2;
780 successoutcome->value.choice.RICsubscriptionResponse = *ricsubresp;
782 E2AP_PDU_PR pres5 = E2AP_PDU_PR_successfulOutcome;
784 e2ap_pdu->present = pres5;
785 e2ap_pdu->choice.successfulOutcome = successoutcome;
787 char *error_buf = (char*)calloc(300, sizeof(char));
790 asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
791 printf("error length %d\n", errlen);
792 printf("error buf %s\n", error_buf);
796 void generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_pdu,
802 uint8_t *ind_header_buf,
804 uint8_t *ind_message_buf,
805 int message_length) {
807 fprintf(stderr, "ind1\n");
808 RICindication_IEs_t *ricind_ies = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
809 RICindication_IEs_t *ricind_ies2 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
810 RICindication_IEs_t *ricind_ies3 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
811 RICindication_IEs_t *ricind_ies4 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
812 RICindication_IEs_t *ricind_ies5 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
813 RICindication_IEs_t *ricind_ies6 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
814 RICindication_IEs_t *ricind_ies7 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
815 RICindication_IEs_t *ricind_ies8 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
817 RICindication_IEs__value_PR pres3;
819 pres3 = RICindication_IEs__value_PR_RICrequestID;
820 ricind_ies->id = ProtocolIE_ID_id_RICrequestID;
821 ricind_ies->criticality = 0;
822 ricind_ies->value.present = pres3;
823 ricind_ies->value.choice.RICrequestID.ricRequestorID = requestorId;
824 ricind_ies->value.choice.RICrequestID.ricInstanceID = instanceId;
826 fprintf(stderr, "ind2\n");
828 pres3 = RICindication_IEs__value_PR_RANfunctionID;
829 ricind_ies2->id = ProtocolIE_ID_id_RANfunctionID;
830 ricind_ies2->criticality = 0;
831 ricind_ies2->value.present = pres3;
832 ricind_ies2->value.choice.RANfunctionID = ranFunctionId;
835 ricind_ies3->id = ProtocolIE_ID_id_RICactionID;
836 ricind_ies3->criticality = 0;
837 pres3 = RICindication_IEs__value_PR_RICactionID;
838 ricind_ies3->value.present = pres3;
839 ricind_ies3->value.choice.RICactionID = actionId;
842 pres3 = RICindication_IEs__value_PR_RICindicationSN;
843 ricind_ies4->id = ProtocolIE_ID_id_RICindicationSN;
844 ricind_ies4->criticality = 0;
845 ricind_ies4->value.present = pres3;
846 ricind_ies4->value.choice.RICindicationSN = seqNum;
848 //Indication type is REPORT
849 pres3 = RICindication_IEs__value_PR_RICindicationType;
850 ricind_ies5->id = ProtocolIE_ID_id_RICindicationType;
851 ricind_ies5->criticality = 0;
852 ricind_ies5->value.present = pres3;
853 ricind_ies5->value.choice.RICindicationType = 0;
856 uint8_t *buf2 = (uint8_t *)"reportheader";
857 OCTET_STRING_t *hdr_str = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
859 hdr_str->buf = (uint8_t*)calloc(1,header_length);
860 hdr_str->size = header_length;
861 memcpy(hdr_str->buf, ind_header_buf, header_length);
863 fprintf(stderr, "ind3\n");
865 ricind_ies6->value.choice.RICindicationHeader.buf = (uint8_t*)calloc(1,header_length);
867 pres3 = RICindication_IEs__value_PR_RICindicationHeader;
868 ricind_ies6->id = ProtocolIE_ID_id_RICindicationHeader;
869 ricind_ies6->criticality = 0;
870 ricind_ies6->value.present = pres3;
871 ricind_ies6->value.choice.RICindicationHeader.size = header_length;
872 memcpy(ricind_ies6->value.choice.RICindicationHeader.buf, ind_header_buf, header_length);
874 ricind_ies7->value.choice.RICindicationMessage.buf = (uint8_t*)calloc(1,8192);
879 pres3 = RICindication_IEs__value_PR_RICindicationMessage;
880 ricind_ies7->id = ProtocolIE_ID_id_RICindicationMessage;
881 fprintf(stderr, "after encoding message 1\n");
883 ricind_ies7->criticality = 0;
884 ricind_ies7->value.present = pres3;
886 fprintf(stderr, "after encoding message 2\n");
888 fprintf(stderr, "after encoding message 3\n");
889 ricind_ies7->value.choice.RICindicationMessage.size = message_length;
891 fprintf(stderr, "after encoding message 4\n");
892 memcpy(ricind_ies7->value.choice.RICindicationMessage.buf, ind_message_buf, message_length);
894 fprintf(stderr, "after encoding message 5\n");
896 uint8_t *cpid_buf = (uint8_t *)"cpid";
897 OCTET_STRING_t cpid_str;
901 int cpid_buf_len = strlen((char*)cpid_buf);
902 pres3 = RICindication_IEs__value_PR_RICcallProcessID;
903 ricind_ies8->id = ProtocolIE_ID_id_RICcallProcessID;
905 ricind_ies8->criticality = 0;
906 ricind_ies8->value.present = pres3;
908 ricind_ies8->value.choice.RICcallProcessID.buf = (uint8_t*)calloc(1,cpid_buf_len);
909 ricind_ies8->value.choice.RICcallProcessID.size = cpid_buf_len;
911 memcpy(ricind_ies8->value.choice.RICcallProcessID.buf, cpid_buf, cpid_buf_len);
915 RICindication_t *ricindication = (RICindication_t*)calloc(1, sizeof(RICindication_t));
920 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies);
922 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies2);
926 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies3);
930 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies4);
934 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies5);
938 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies6);
942 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies7);
944 // ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies8);
947 InitiatingMessage__value_PR pres4;
948 pres4 = InitiatingMessage__value_PR_RICindication;
949 InitiatingMessage_t *initmsg = (InitiatingMessage_t*)calloc(1, sizeof(InitiatingMessage_t));
950 initmsg->procedureCode = 5;
951 initmsg->criticality = 1;
952 initmsg->value.present = pres4;
953 initmsg->value.choice.RICindication = *ricindication;
956 pres5 = E2AP_PDU_PR_initiatingMessage;
958 e2ap_pdu->present = pres5;
959 e2ap_pdu->choice.initiatingMessage = initmsg;
961 char *error_buf = (char*)calloc(300, sizeof(char));
964 asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
965 printf("error length %d\n", errlen);
966 printf("error buf %s\n", error_buf);
968 xer_fprint(stderr, &asn_DEF_E2AP_PDU, e2ap_pdu);
972 void generate_e2apv1_indication_request(E2AP_PDU *e2ap_pdu) {
973 fprintf(stderr, "ind1\n");
974 RICindication_IEs_t *ricind_ies = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
975 RICindication_IEs_t *ricind_ies2 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
976 RICindication_IEs_t *ricind_ies3 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
977 RICindication_IEs_t *ricind_ies4 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
978 RICindication_IEs_t *ricind_ies5 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
979 RICindication_IEs_t *ricind_ies6 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
980 RICindication_IEs_t *ricind_ies7 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
981 RICindication_IEs_t *ricind_ies8 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
983 RICindication_IEs__value_PR pres3;
985 pres3 = RICindication_IEs__value_PR_RICrequestID;
986 ricind_ies->id = ProtocolIE_ID_id_RICrequestID;
987 ricind_ies->criticality = 0;
988 ricind_ies->value.present = pres3;
989 ricind_ies->value.choice.RICrequestID.ricRequestorID = 25;
990 ricind_ies->value.choice.RICrequestID.ricInstanceID = 3;
992 fprintf(stderr, "ind2\n");
994 pres3 = RICindication_IEs__value_PR_RANfunctionID;
995 ricind_ies2->id = ProtocolIE_ID_id_RANfunctionID;
996 ricind_ies2->criticality = 0;
997 ricind_ies2->value.present = pres3;
998 ricind_ies2->value.choice.RANfunctionID = 70;
1001 ricind_ies3->id = ProtocolIE_ID_id_RICactionID;
1002 ricind_ies3->criticality = 0;
1003 pres3 = RICindication_IEs__value_PR_RICactionID;
1004 ricind_ies3->value.present = pres3;
1005 ricind_ies3->value.choice.RICactionID = 80;
1008 pres3 = RICindication_IEs__value_PR_RICindicationSN;
1009 ricind_ies4->id = ProtocolIE_ID_id_RICindicationSN;
1010 ricind_ies4->criticality = 0;
1011 ricind_ies4->value.present = pres3;
1012 ricind_ies4->value.choice.RICindicationSN = 45;
1014 pres3 = RICindication_IEs__value_PR_RICindicationType;
1015 ricind_ies5->id = ProtocolIE_ID_id_RICindicationType;
1016 ricind_ies5->criticality = 0;
1017 ricind_ies5->value.present = pres3;
1018 ricind_ies5->value.choice.RICindicationType = 0;
1021 uint8_t *buf2 = (uint8_t *)"reportheader";
1022 OCTET_STRING_t *hdr_str = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
1023 hdr_str->buf = (uint8_t*)calloc(1,12);
1025 memcpy(hdr_str->buf, buf2, 12);
1027 fprintf(stderr, "ind3\n");
1029 ricind_ies6->value.choice.RICindicationHeader.buf = (uint8_t*)calloc(1,12);
1031 pres3 = RICindication_IEs__value_PR_RICindicationHeader;
1032 ricind_ies6->id = ProtocolIE_ID_id_RICindicationHeader;
1033 ricind_ies6->criticality = 0;
1034 ricind_ies6->value.present = pres3;
1035 ricind_ies6->value.choice.RICindicationHeader.size = 12;
1036 memcpy(ricind_ies6->value.choice.RICindicationHeader.buf, buf2, 12);
1038 ricind_ies7->value.choice.RICindicationMessage.buf = (uint8_t*)calloc(1,8192);
1042 E2SM_KPM_RANfunction_Description_t *e2sm_desc =
1043 (E2SM_KPM_RANfunction_Description_t*)calloc(1,sizeof(E2SM_KPM_RANfunction_Description_t));
1045 encode_kpm_function_description(e2sm_desc);
1048 uint8_t e2smbuffer[8192];
1049 size_t e2smbuffer_size = 8192;
1051 asn_codec_ctx_t *opt_cod;
1055 asn_encode_to_buffer(opt_cod,
1056 ATS_ALIGNED_BASIC_PER,
1057 &asn_DEF_E2SM_KPM_RANfunction_Description,
1058 e2sm_desc, e2smbuffer, e2smbuffer_size);
1061 fprintf(stderr, "er encded is %d\n", er.encoded);
1062 fprintf(stderr, "after encoding message\n");
1064 OCTET_STRING_t *msg_str = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
1065 msg_str->buf = (uint8_t*)calloc(1,er.encoded);
1066 msg_str->size = er.encoded;
1067 memcpy(msg_str->buf, e2smbuffer, er.encoded);
1070 pres3 = RICindication_IEs__value_PR_RICindicationMessage;
1071 ricind_ies7->id = ProtocolIE_ID_id_RICindicationMessage;
1072 fprintf(stderr, "after encoding message 1\n");
1074 ricind_ies7->criticality = 0;
1075 ricind_ies7->value.present = pres3;
1077 fprintf(stderr, "after encoding message 2\n");
1079 fprintf(stderr, "after encoding message 3\n");
1080 ricind_ies7->value.choice.RICindicationMessage.size = er.encoded;
1082 fprintf(stderr, "after encoding message 4\n");
1083 memcpy(ricind_ies7->value.choice.RICindicationMessage.buf, e2smbuffer, er.encoded);
1085 fprintf(stderr, "after encoding message 5\n");
1087 uint8_t *buf4 = (uint8_t *)"cpid";
1088 OCTET_STRING_t cpid_str;
1089 cpid_str.buf = buf4;
1093 pres3 = RICindication_IEs__value_PR_RICcallProcessID;
1094 ricind_ies8->id = ProtocolIE_ID_id_RICcallProcessID;
1096 ricind_ies8->criticality = 0;
1097 ricind_ies8->value.present = pres3;
1099 ricind_ies8->value.choice.RICcallProcessID = cpid_str;
1102 RICindication_t *ricindication = (RICindication_t*)calloc(1, sizeof(RICindication_t));
1107 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies);
1109 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies2);
1111 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies3);
1112 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies4);
1113 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies5);
1115 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies6);
1117 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies7);
1119 ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies8);
1122 InitiatingMessage__value_PR pres4;
1123 pres4 = InitiatingMessage__value_PR_RICindication;
1124 InitiatingMessage_t *initmsg = (InitiatingMessage_t*)calloc(1, sizeof(InitiatingMessage_t));
1125 initmsg->procedureCode = 5;
1126 initmsg->criticality = 1;
1127 initmsg->value.present = pres4;
1128 initmsg->value.choice.RICindication = *ricindication;
1131 pres5 = E2AP_PDU_PR_initiatingMessage;
1133 e2ap_pdu->present = pres5;
1134 e2ap_pdu->choice.initiatingMessage = initmsg;
1136 char *error_buf = (char*)calloc(300, sizeof(char));;
1139 asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
1140 printf("error length %d\n", errlen);
1141 printf("error buf %s\n", error_buf);
1143 xer_fprint(stderr, &asn_DEF_E2AP_PDU, e2ap_pdu);
1147 void generate_e2apv1_indication_response(E2AP_PDU *e2ap_pdu) {