4 size_t encode_E2AP_PDU(E2AP_PDU_t* pdu, void* buffer, size_t buf_size)
6 asn_enc_rval_t encode_result;
7 encode_result = aper_encode_to_buffer(&asn_DEF_E2AP_PDU, NULL, pdu, buffer, buf_size);
8 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
9 if(encode_result.encoded == -1) {
10 fprintf(stderr, "Cannot encode %s: %s\n", encode_result.failed_type->name, strerror(errno));
13 return encode_result.encoded;
17 E2AP_PDU_t* decode_E2AP_PDU(const void* buffer, size_t buf_size)
19 asn_dec_rval_t decode_result;
21 decode_result = aper_decode_complete(NULL, &asn_DEF_E2AP_PDU, (void **)&pdu, buffer, buf_size);
22 //xer_fprint(stderr, &asn_DEF_E2AP_PDU,pdu);
23 if(decode_result.code == RC_OK) {
24 xer_fprint(stderr, &asn_DEF_E2AP_PDU,pdu);
27 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
32 /* RICsubscriptionRequest */
33 long e2ap_get_ric_subscription_request_sequence_number(void *buffer, size_t buf_size)
35 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
36 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
38 InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
39 if ( initiatingMessage->procedureCode == ProcedureCode_id_RICsubscription
40 && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionRequest)
42 RICsubscriptionRequest_t *ric_subscription_request = &(initiatingMessage->value.choice.RICsubscriptionRequest);
43 for (int i = 0; i < ric_subscription_request->protocolIEs.list.count; ++i )
45 if ( ric_subscription_request->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
47 long sequenceNumber = ric_subscription_request->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
48 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
49 return sequenceNumber;
56 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
60 ssize_t e2ap_set_ric_subscription_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
62 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
63 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
65 InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
66 if ( initiatingMessage->procedureCode == ProcedureCode_id_RICsubscription
67 && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionRequest)
69 RICsubscriptionRequest_t *ricSubscriptionRequest = &initiatingMessage->value.choice.RICsubscriptionRequest;
70 for (int i = 0; i < ricSubscriptionRequest->protocolIEs.list.count; ++i )
72 if ( ricSubscriptionRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
74 ricSubscriptionRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID = sequence_number;
75 return encode_E2AP_PDU(pdu, buffer, buf_size);
82 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
86 ssize_t e2ap_encode_ric_subscription_request_message(void *buffer, size_t buf_size, long ricRequestorID, long ricRequestSequenceNumber, long ranFunctionID, void *eventTriggerDefinition, size_t eventTriggerDefinitionSize, int actionCount, long *actionIds, long* actionTypes, RICactionDefinition *actionDefinitions, RICSubsequentAction *subsequentActionTypes)
88 E2AP_PDU_t *init = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t));
90 fprintf(stderr, "alloc E2AP_PDU failed\n");
94 InitiatingMessage_t *initiatingMsg = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t));
96 fprintf(stderr, "alloc InitiatingMessage failed\n");
97 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
101 init->choice.initiatingMessage = initiatingMsg;
102 init->present = E2AP_PDU_PR_initiatingMessage;
104 initiatingMsg->procedureCode = ProcedureCode_id_RICsubscription;
105 initiatingMsg->criticality = Criticality_reject;
106 initiatingMsg->value.present = InitiatingMessage__value_PR_RICsubscriptionRequest;
108 RICsubscriptionRequest_t *subscription_request = &initiatingMsg->value.choice.RICsubscriptionRequest;
110 // request contains 5 IEs
113 RICsubscriptionRequest_IEs_t *ies_reqID = (RICsubscriptionRequest_IEs_t *)calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
115 fprintf(stderr, "alloc RICrequestID failed\n");
116 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
120 ies_reqID->criticality = Criticality_reject;
121 ies_reqID->id = ProtocolIE_ID_id_RICrequestID;
122 ies_reqID->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
123 RICrequestID_t *ricrequest_ie = &ies_reqID->value.choice.RICrequestID;
124 ricrequest_ie->ricRequestorID = ricRequestorID;
125 ricrequest_ie->ricInstanceID = ricRequestSequenceNumber;
126 ASN_SEQUENCE_ADD(&subscription_request->protocolIEs.list, ies_reqID);
129 RICsubscriptionRequest_IEs_t *ies_ranfunc = (RICsubscriptionRequest_IEs_t *)calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
131 fprintf(stderr, "alloc RICfunctionID failed\n");
132 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
136 ies_ranfunc->criticality = Criticality_reject;
137 ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
138 ies_ranfunc->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
139 RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
140 *ranfunction_ie = ranFunctionID;
141 ASN_SEQUENCE_ADD(&subscription_request->protocolIEs.list, ies_ranfunc);
144 RICsubscriptionRequest_IEs_t *ies_subscription = (RICsubscriptionRequest_IEs_t *)calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
145 if(!ies_subscription) {
146 fprintf(stderr, "alloc RICsubscription failed\n");
147 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
151 ies_subscription->criticality = Criticality_reject;
152 ies_subscription->id = ProtocolIE_ID_id_RICsubscriptionDetails;
153 ies_subscription->value.present = RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
154 RICsubscriptionDetails_t *ricsubscription_ie = &ies_subscription->value.choice.RICsubscriptionDetails;
156 // RICeventTriggerDefinition
157 RICeventTriggerDefinition_t *eventTrigger = &ricsubscription_ie->ricEventTriggerDefinition;
158 eventTrigger->buf = (uint8_t *)calloc(1, eventTriggerDefinitionSize);
159 if(!eventTrigger->buf) {
160 fprintf(stderr, "alloc eventTrigger failed\n");
161 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
165 memcpy(eventTrigger->buf, eventTriggerDefinition, eventTriggerDefinitionSize);
166 eventTrigger->size = eventTriggerDefinitionSize;
168 // RICactions-ToBeSetup-List
169 RICactions_ToBeSetup_List_t *ricActions = &ricsubscription_ie->ricAction_ToBeSetup_List;
171 while (index < actionCount) {
172 RICaction_ToBeSetup_ItemIEs_t *ies_action = (RICaction_ToBeSetup_ItemIEs_t *)calloc(1, sizeof(RICaction_ToBeSetup_ItemIEs_t));
174 fprintf(stderr, "alloc RICaction failed\n");
175 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
179 ies_action->criticality = Criticality_reject;
180 ies_action->id = ProtocolIE_ID_id_RICaction_ToBeSetup_Item;
181 ies_action->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
182 RICaction_ToBeSetup_Item_t *ricaction_ie = &ies_action->value.choice.RICaction_ToBeSetup_Item;
183 ricaction_ie->ricActionID = actionIds[index];
184 ricaction_ie->ricActionType = actionTypes[index];
186 int actionDefinitionSize = actionDefinitions[index].size;
187 if(actionDefinitionSize != 0) {
188 RICactionDefinition_t *actionDefinition = ricaction_ie->ricActionDefinition;
190 actionDefinition->buf = (uint8_t *)calloc(1, actionDefinitionSize);
191 if(!actionDefinition->buf) {
192 fprintf(stderr, "alloc actionDefinition[%d] failed\n", index);
193 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
197 memcpy(actionDefinition->buf, actionDefinitions[index].actionDefinition, actionDefinitionSize);
198 actionDefinition->size = actionDefinitionSize;
201 if(subsequentActionTypes[index].isValid != 0) {
202 RICsubsequentAction_t *subsequentAction = ricaction_ie->ricSubsequentAction;
203 subsequentAction->ricSubsequentActionType = subsequentActionTypes[index].subsequentActionType;
204 subsequentAction->ricTimeToWait = subsequentActionTypes[index].timeToWait;
207 ASN_SEQUENCE_ADD(&ricActions->list, ies_action);
210 ASN_SEQUENCE_ADD(&subscription_request->protocolIEs.list, ies_subscription);
212 return encode_E2AP_PDU(init, buffer, buf_size);
215 /* RICsubscriptionResponse */
216 long e2ap_get_ric_subscription_response_sequence_number(void *buffer, size_t buf_size)
218 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
219 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
221 SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
222 if ( successfulOutcome->procedureCode == ProcedureCode_id_RICsubscription
223 && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse)
225 RICsubscriptionResponse_t *ricSubscriptionResponse = &successfulOutcome->value.choice.RICsubscriptionResponse;
226 for (int i = 0; i < ricSubscriptionResponse->protocolIEs.list.count; ++i )
228 if ( ricSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
230 long sequenceNumber = ricSubscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
231 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
232 return sequenceNumber;
239 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
243 ssize_t e2ap_set_ric_subscription_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
245 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
246 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
248 SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
249 if ( successfulOutcome->procedureCode == ProcedureCode_id_RICsubscription
250 && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse)
252 RICsubscriptionResponse_t *ricSubscriptionResponse = &successfulOutcome->value.choice.RICsubscriptionResponse;
253 for (int i = 0; i < ricSubscriptionResponse->protocolIEs.list.count; ++i )
255 if ( ricSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
257 ricSubscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID = sequence_number;
258 return encode_E2AP_PDU(pdu, buffer, buf_size);
265 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
269 RICsubscriptionResponseMsg* e2ap_decode_ric_subscription_response_message(void *buffer, size_t buf_size)
271 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
272 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
274 SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
275 if ( successfulOutcome->procedureCode == ProcedureCode_id_RICsubscription
276 && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse)
278 RICsubscriptionResponse_t *subscriptionResponse = &(successfulOutcome->value.choice.RICsubscriptionResponse);
279 RICsubscriptionResponseMsg *msg = (RICsubscriptionResponseMsg *)calloc(1, sizeof(RICsubscriptionResponseMsg));
280 for (int i = 0; i < subscriptionResponse->protocolIEs.list.count; ++i )
282 if (subscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID) {
283 msg->requestorID = subscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
284 msg->requestSequenceNumber = subscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
286 else if (subscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
287 msg->ranfunctionID = subscriptionResponse->protocolIEs.list.array[i]->value.choice.RANfunctionID;
289 else if (subscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactions_Admitted) {
290 RICaction_Admitted_List_t *ricActionAdmittedList = &(subscriptionResponse->protocolIEs.list.array[i]->value.choice.RICaction_Admitted_List);
292 while (index < ricActionAdmittedList->list.count) {
293 RICaction_Admitted_ItemIEs_t *ricActionAdmittedItem = (RICaction_Admitted_ItemIEs_t *)ricActionAdmittedList->list.array[index];
294 if (ricActionAdmittedItem->id == ProtocolIE_ID_id_RICaction_Admitted_Item) {
295 msg->ricActionAdmittedList.ricActionID[index] = ricActionAdmittedItem->value.choice.RICaction_Admitted_Item.ricActionID;
299 msg->ricActionAdmittedList.count = index;
301 else if (subscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactions_NotAdmitted) {
302 RICaction_NotAdmitted_List_t *ricActionNotAdmittedList = &(subscriptionResponse->protocolIEs.list.array[i]->value.choice.RICaction_NotAdmitted_List);
304 while (index < ricActionNotAdmittedList->list.count) {
305 RICaction_NotAdmitted_ItemIEs_t *ricActionNotAdmittedItem = (RICaction_NotAdmitted_ItemIEs_t *)ricActionNotAdmittedList->list.array[index];
306 if (ricActionNotAdmittedItem->id == ProtocolIE_ID_id_RICaction_NotAdmitted_Item) {
307 msg->ricActionNotAdmittedList.ricActionID[index] = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.ricActionID;
308 int RICcauseType = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.present;
309 switch(RICcauseType) {
310 case Cause_PR_ricRequest:
311 msg->ricActionNotAdmittedList.ricCause[index].ricCauseType = Cause_PR_ricRequest;
312 msg->ricActionNotAdmittedList.ricCause[index].ricCauseID = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest;
314 case Cause_PR_ricService:
315 msg->ricActionNotAdmittedList.ricCause[index].ricCauseType = Cause_PR_ricService;
316 msg->ricActionNotAdmittedList.ricCause[index].ricCauseID = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService;
318 case Cause_PR_transport:
319 msg->ricActionNotAdmittedList.ricCause[index].ricCauseType = Cause_PR_transport;
320 msg->ricActionNotAdmittedList.ricCause[index].ricCauseID = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport;
322 case Cause_PR_protocol:
323 msg->ricActionNotAdmittedList.ricCause[index].ricCauseType = Cause_PR_protocol;
324 msg->ricActionNotAdmittedList.ricCause[index].ricCauseID = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol;
327 msg->ricActionNotAdmittedList.ricCause[index].ricCauseType = Cause_PR_misc;
328 msg->ricActionNotAdmittedList.ricCause[index].ricCauseID = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc;
334 msg->ricActionNotAdmittedList.count = index;
343 /* RICsubscriptionFailure */
344 long e2ap_get_ric_subscription_failure_sequence_number(void *buffer, size_t buf_size)
346 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
347 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome )
349 UnsuccessfulOutcome_t* unsuccessfulOutcome = pdu->choice.unsuccessfulOutcome;
350 if ( unsuccessfulOutcome->procedureCode == ProcedureCode_id_RICsubscription
351 && unsuccessfulOutcome->value.present == UnsuccessfulOutcome__value_PR_RICsubscriptionFailure)
353 RICsubscriptionFailure_t *ricSubscriptionFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
354 for (int i = 0; i < ricSubscriptionFailure->protocolIEs.list.count; ++i )
356 if ( ricSubscriptionFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
358 long sequenceNumber = ricSubscriptionFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
359 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
360 return sequenceNumber;
367 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
371 /* RICsubscriptionDeleteRequest */
372 long e2ap_get_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size)
374 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
375 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage )
377 InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
378 if ( initiatingMessage->procedureCode == ProcedureCode_id_RICsubscriptionDelete
379 && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionDeleteRequest )
381 RICsubscriptionDeleteRequest_t *subscriptionDeleteRequest = &initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
382 for (int i = 0; i < subscriptionDeleteRequest->protocolIEs.list.count; ++i )
384 if ( subscriptionDeleteRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
386 long sequenceNumber = subscriptionDeleteRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
387 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
388 return sequenceNumber;
395 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
399 ssize_t e2ap_set_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
401 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
402 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage )
404 InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
405 if ( initiatingMessage->procedureCode == ProcedureCode_id_RICsubscriptionDelete
406 && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionDeleteRequest )
408 RICsubscriptionDeleteRequest_t* subscriptionDeleteRequest = &initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
409 for (int i = 0; i < subscriptionDeleteRequest->protocolIEs.list.count; ++i )
411 if ( subscriptionDeleteRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
413 subscriptionDeleteRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID = sequence_number;
414 return encode_E2AP_PDU(pdu, buffer, buf_size);
421 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
425 ssize_t e2ap_encode_ric_subscription_delete_request_message(void *buffer, size_t buf_size, long ricRequestorID, long ricRequestSequenceNumber, long ranFunctionID)
427 E2AP_PDU_t *init = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t));
429 fprintf(stderr, "alloc E2AP_PDU failed\n");
433 InitiatingMessage_t *initiatingMsg = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t));
435 fprintf(stderr, "alloc InitiatingMessage failed\n");
436 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
440 init->choice.initiatingMessage = initiatingMsg;
441 init->present = E2AP_PDU_PR_initiatingMessage;
443 initiatingMsg->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
444 initiatingMsg->criticality = Criticality_reject;
445 initiatingMsg->value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequest;
447 RICsubscriptionDeleteRequest_t *subscription_delete_request = &initiatingMsg->value.choice.RICsubscriptionDeleteRequest;
449 // request contains 2 IEs
452 RICsubscriptionDeleteRequest_IEs_t *ies_reqID = (RICsubscriptionDeleteRequest_IEs_t *)calloc(1, sizeof(RICsubscriptionDeleteRequest_IEs_t));
454 fprintf(stderr, "alloc RICrequestID failed\n");
455 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
459 ies_reqID->criticality = Criticality_reject;
460 ies_reqID->id = ProtocolIE_ID_id_RICrequestID;
461 ies_reqID->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RICrequestID;
462 RICrequestID_t *ricrequest_ie = &ies_reqID->value.choice.RICrequestID;
463 ricrequest_ie->ricRequestorID = ricRequestorID;
464 ricrequest_ie->ricInstanceID = ricRequestSequenceNumber;
465 ASN_SEQUENCE_ADD(&subscription_delete_request->protocolIEs.list, ies_reqID);
468 RICsubscriptionDeleteRequest_IEs_t *ies_ranfunc = (RICsubscriptionDeleteRequest_IEs_t *)calloc(1, sizeof(RICsubscriptionDeleteRequest_IEs_t));
470 fprintf(stderr, "alloc RICfunctionID failed\n");
471 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
475 ies_ranfunc->criticality = Criticality_reject;
476 ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
477 ies_ranfunc->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RANfunctionID;
478 RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
479 *ranfunction_ie = ranFunctionID;
480 ASN_SEQUENCE_ADD(&subscription_delete_request->protocolIEs.list, ies_ranfunc);
482 return encode_E2AP_PDU(init, buffer, buf_size);
485 /* RICsubscriptionDeleteResponse */
486 long e2ap_get_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size)
488 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
489 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
491 SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
492 if ( successfulOutcome->procedureCode == ProcedureCode_id_RICsubscriptionDelete
493 && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse )
495 RICsubscriptionDeleteResponse_t* subscriptionDeleteResponse = &successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
496 for (int i = 0; i < subscriptionDeleteResponse->protocolIEs.list.count; ++i )
498 if ( subscriptionDeleteResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
500 long sequenceNumber = subscriptionDeleteResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
501 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
502 return sequenceNumber;
509 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
513 ssize_t e2ap_set_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
515 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
516 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
518 SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
519 if ( successfulOutcome->procedureCode == ProcedureCode_id_RICsubscriptionDelete
520 && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse )
522 RICsubscriptionDeleteResponse_t* subscriptionDeleteResponse = &successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
523 for (int i = 0; i < subscriptionDeleteResponse->protocolIEs.list.count; ++i )
525 if ( subscriptionDeleteResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
527 subscriptionDeleteResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID = sequence_number;
528 return encode_E2AP_PDU(pdu, buffer, buf_size);
535 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
539 /* RICsubscriptionDeleteFailure */
540 long e2ap_get_ric_subscription_delete_failure_sequence_number(void *buffer, size_t buf_size)
542 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
543 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome )
545 UnsuccessfulOutcome_t* unsuccessfulOutcome = pdu->choice.unsuccessfulOutcome;
546 if ( unsuccessfulOutcome->procedureCode == ProcedureCode_id_RICsubscriptionDelete
547 && unsuccessfulOutcome->value.present == UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure)
549 RICsubscriptionDeleteFailure_t *ricSubscriptionDeleteFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
550 for (int i = 0; i < ricSubscriptionDeleteFailure->protocolIEs.list.count; ++i )
552 if ( ricSubscriptionDeleteFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
554 long sequenceNumber = ricSubscriptionDeleteFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
555 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
556 return sequenceNumber;
563 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
569 RICindicationMsg* e2ap_decode_ric_indication_message(void *buffer, size_t buf_size)
571 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
572 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
574 InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
575 if ( initiatingMessage->procedureCode == ProcedureCode_id_RICindication
576 && initiatingMessage->value.present == InitiatingMessage__value_PR_RICindication)
578 RICindication_t *indication = &(initiatingMessage->value.choice.RICindication);
579 RICindicationMsg *msg = (RICindicationMsg *)calloc(1, sizeof(RICindicationMsg));
580 for (int i = 0; i < indication->protocolIEs.list.count; ++i )
582 if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID) {
583 msg->requestorID = indication->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
584 msg->requestSequenceNumber = indication->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
586 else if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
587 msg->ranfunctionID = indication->protocolIEs.list.array[i]->value.choice.RANfunctionID;
589 else if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactionID) {
590 msg->actionID = indication->protocolIEs.list.array[i]->value.choice.RICactionID;
592 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationSN) {
593 msg->indicationSN = indication->protocolIEs.list.array[i]->value.choice.RICindicationSN;
595 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationType) {
596 msg->indicationType = indication->protocolIEs.list.array[i]->value.choice.RICindicationType;
598 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationHeader) {
599 size_t headerSize = indication->protocolIEs.list.array[i]->value.choice.RICindicationHeader.size;
600 msg->indicationHeader = calloc(1, headerSize);
601 if (!msg->indicationHeader) {
602 fprintf(stderr, "alloc RICindicationHeader failed\n");
603 e2ap_free_decoded_ric_indication_message(msg);
604 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
608 memcpy(msg->indicationHeader, indication->protocolIEs.list.array[i]->value.choice.RICindicationHeader.buf, headerSize);
609 msg->indicationHeaderSize = headerSize;
611 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationMessage) {
612 size_t messsageSize = indication->protocolIEs.list.array[i]->value.choice.RICindicationMessage.size;
613 msg->indicationMessage = calloc(1, messsageSize);
614 if (!msg->indicationMessage) {
615 fprintf(stderr, "alloc RICindicationMessage failed\n");
616 e2ap_free_decoded_ric_indication_message(msg);
617 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
621 memcpy(msg->indicationMessage, indication->protocolIEs.list.array[i]->value.choice.RICindicationMessage.buf, messsageSize);
622 msg->indicationMessageSize = messsageSize;
624 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcallProcessID) {
625 size_t callProcessIDSize = indication->protocolIEs.list.array[i]->value.choice.RICcallProcessID.size;
626 msg->callProcessID = calloc(1, callProcessIDSize);
627 if (!msg->callProcessID) {
628 fprintf(stderr, "alloc RICcallProcessID failed\n");
629 e2ap_free_decoded_ric_indication_message(msg);
630 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
634 memcpy(msg->callProcessID, indication->protocolIEs.list.array[i]->value.choice.RICcallProcessID.buf, callProcessIDSize);
635 msg->callProcessIDSize = callProcessIDSize;
643 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
648 RICindicationMsg* e2ap_decode_ric_indication_m()
652 FILE *fp3 = fopen("sandy3.txt", "r");
655 printf("\nFAILED TO OPEN FILE SANDY3.TXT");
658 fseek(fp3, 0L, SEEK_END);
659 long numbytes = ftell(fp3);
660 fseek(fp3, 0L, SEEK_SET);
661 char* text = (char*)calloc(numbytes, sizeof(char));
662 fread(text, sizeof(char), numbytes, fp3);
666 asn_dec_rval_t lol =xer_decode(0,&asn_DEF_E2AP_PDU, (void **)&pdu,text,numbytes);
667 printf("\nxer decode result =%d",lol.code);
668 FILE *fp4 = fopen("sandy4.txt", "w");
669 int r2=asn_fprint(fp4,&asn_DEF_E2AP_PDU,pdu);
672 fprintf(stderr, "failed asn_fprint r2\n");
674 fprintf(stderr, "successfull asn_fprint r2\n");
677 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
679 InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
680 if ( initiatingMessage->procedureCode == ProcedureCode_id_RICindication
681 && initiatingMessage->value.present == InitiatingMessage__value_PR_RICindication)
683 RICindication_t *indication = &(initiatingMessage->value.choice.RICindication);
684 RICindicationMsg *msg = (RICindicationMsg *)calloc(1, sizeof(RICindicationMsg));
685 for (int i = 0; i < indication->protocolIEs.list.count; ++i )
687 if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID) {
688 msg->requestorID = indication->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
689 msg->requestSequenceNumber = indication->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
691 else if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
692 msg->ranfunctionID = indication->protocolIEs.list.array[i]->value.choice.RANfunctionID;
694 else if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactionID) {
695 msg->actionID = indication->protocolIEs.list.array[i]->value.choice.RICactionID;
697 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationSN) {
698 msg->indicationSN = indication->protocolIEs.list.array[i]->value.choice.RICindicationSN;
700 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationType) {
701 msg->indicationType = indication->protocolIEs.list.array[i]->value.choice.RICindicationType;
703 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationHeader) {
704 size_t headerSize = indication->protocolIEs.list.array[i]->value.choice.RICindicationHeader.size;
705 msg->indicationHeader = calloc(1, headerSize);
706 if (!msg->indicationHeader) {
707 fprintf(stderr, "alloc RICindicationHeader failed\n");
708 e2ap_free_decoded_ric_indication_message(msg);
709 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
713 memcpy(msg->indicationHeader, indication->protocolIEs.list.array[i]->value.choice.RICindicationHeader.buf, headerSize);
714 msg->indicationHeaderSize = headerSize;
716 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationMessage) {
717 size_t messsageSize = indication->protocolIEs.list.array[i]->value.choice.RICindicationMessage.size;
718 msg->indicationMessage = calloc(1, messsageSize);
719 if (!msg->indicationMessage) {
720 fprintf(stderr, "alloc RICindicationMessage failed\n");
721 e2ap_free_decoded_ric_indication_message(msg);
722 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
726 memcpy(msg->indicationMessage, indication->protocolIEs.list.array[i]->value.choice.RICindicationMessage.buf, messsageSize);
727 msg->indicationMessageSize = messsageSize;
729 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcallProcessID) {
730 size_t callProcessIDSize = indication->protocolIEs.list.array[i]->value.choice.RICcallProcessID.size;
731 msg->callProcessID = calloc(1, callProcessIDSize);
732 if (!msg->callProcessID) {
733 fprintf(stderr, "alloc RICcallProcessID failed\n");
734 e2ap_free_decoded_ric_indication_message(msg);
735 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
739 memcpy(msg->callProcessID, indication->protocolIEs.list.array[i]->value.choice.RICcallProcessID.buf, callProcessIDSize);
740 msg->callProcessIDSize = callProcessIDSize;
744 RICindicationHeader_t *hdr;
745 hdr=calloc(1, sizeof(RICindicationHeader_t));
746 memcpy( hdr->buf,msg->indicationHeader,msg->indicationHeaderSize);
747 hdr->size=msg->indicationHeaderSize;
748 xer_fprint(stdout, &asn_DEF_RICindicationHeader,hdr);
749 RICindicationMessage_t *indm;
750 indm=calloc(1, sizeof(RICindicationMessage_t));
751 memcpy(indm->buf, msg->indicationMessage,msg->indicationMessageSize);
752 indm->size=msg->indicationMessageSize;
753 xer_fprint(stdout, &asn_DEF_RICindicationMessage, indm);
755 // fprintf(stderr, "\nreturning msg\n");
760 //fprintf(stderr, "\nreturning null");
762 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
766 void e2ap_free_decoded_ric_indication_message(RICindicationMsg* msg) {
771 if(msg->indicationHeader != NULL) {
772 free(msg->indicationHeader);
773 msg->indicationHeader = NULL;
775 if(msg->indicationMessage != NULL) {
776 free(msg->indicationMessage);
777 msg->indicationMessage = NULL;
779 if(msg->callProcessID != NULL) {
780 free(msg->callProcessID);
781 msg->callProcessID = NULL;
787 ssize_t e2ap_encode_ric_control_request_message(void *buffer, size_t buf_size, long ricRequestorID, long ricRequestSequenceNumber,
788 long ranFunctionID, void *ricControlHdr, size_t ricControlHdrSize, void *ricControlMsg, size_t ricControlMsgSize)
791 E2AP_PDU_t *init = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t));
793 fprintf(stderr, "alloc E2AP_PDU failed\n");
798 InitiatingMessage_t *initiatingMsg = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t));
800 fprintf(stderr, "alloc InitiatingMessage failed\n");
801 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
805 init->choice.initiatingMessage = initiatingMsg;
806 init->present = E2AP_PDU_PR_initiatingMessage;
808 initiatingMsg->procedureCode = ProcedureCode_id_RICcontrol;
809 initiatingMsg->criticality = Criticality_reject;
810 initiatingMsg->value.present = InitiatingMessage__value_PR_RICcontrolRequest;
812 RICcontrolRequest_t *control_request = &initiatingMsg->value.choice.RICcontrolRequest;
816 RICcontrolRequest_IEs_t *controlReqID = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
818 fprintf(stderr, "alloc RICrequestID failed\n");
819 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
823 controlReqID->criticality = Criticality_reject;
824 controlReqID->id = ProtocolIE_ID_id_RICrequestID;
826 controlReqID->value.present = RICcontrolRequest_IEs__value_PR_RICrequestID;
827 RICrequestID_t *ricrequest_ie = &controlReqID->value.choice.RICrequestID;
828 ricrequest_ie->ricRequestorID = ricRequestorID;
829 ricrequest_ie->ricInstanceID = ricRequestSequenceNumber;
830 ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqID);
833 RICcontrolRequest_IEs_t *controlReqFunID = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
834 if(!controlReqFunID) {
835 fprintf(stderr, "alloc RICrequestID failed\n");
836 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
840 controlReqFunID->criticality = Criticality_reject;
841 controlReqFunID->id = ProtocolIE_ID_id_RANfunctionID;
842 controlReqFunID->value.present = RICcontrolRequest_IEs__value_PR_RANfunctionID;
843 RANfunctionID_t *ranfunction_ie = &controlReqFunID->value.choice.RANfunctionID;
844 *ranfunction_ie = ranFunctionID;
845 ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqFunID);
848 RICcontrolRequest_IEs_t *controlReqHdr = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
850 fprintf(stderr, "alloc RICcontrolRequest_IEs_t failed\n");
851 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
854 controlReqHdr->criticality = Criticality_reject;
855 controlReqHdr->id = ProtocolIE_ID_id_RICcontrolHeader;
856 controlReqHdr->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolHeader;
857 RICcontrolHeader_t *controlHdr = &controlReqHdr->value.choice.RICcontrolHeader;
858 controlHdr->buf = (uint8_t *)calloc(1, ricControlHdrSize);
859 if(!controlHdr->buf) {
860 fprintf(stderr, "alloc RICcontrolHeader_t buf failed\n");
861 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
865 memcpy(controlHdr->buf, ricControlHdr, ricControlHdrSize);
866 controlHdr->size = ricControlHdrSize;
867 ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqHdr);
869 //Ric Control Message
870 RICcontrolRequest_IEs_t *controlReqMsg = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
872 fprintf(stderr, "alloc RICcontrolRequest_IEs_t failed\n");
873 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
876 controlReqMsg->criticality = Criticality_reject;
877 controlReqMsg->id = ProtocolIE_ID_id_RICcontrolMessage;
878 controlReqMsg->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolMessage;
879 RICcontrolMessage_t *controlMsg = &controlReqMsg->value.choice.RICcontrolMessage;
880 controlMsg->buf = (uint8_t *)calloc(1, ricControlMsgSize);
881 if(!controlMsg->buf) {
882 fprintf(stderr, "alloc RICcontrolMessage_t buf failed\n");
883 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
887 memcpy(controlMsg->buf, ricControlMsg, ricControlMsgSize);
888 controlMsg->size = ricControlMsgSize;
889 ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqMsg);
891 fprintf(stderr, "showing xer of asn_DEF_E2AP_PDU data\n");
892 xer_fprint(stderr, &asn_DEF_E2AP_PDU, init);
893 fprintf(stderr, "\n");
894 fprintf(stderr, "After xer of asn_DEF_E2AP_PDU data\n");
896 return encode_E2AP_PDU(init, buffer, buf_size);
899 RICControlAcknowledge* e2ap_decode_ric_control_acknowledge_message(void *buffer, size_t buf_size)
901 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
902 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
904 SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
905 if ( successfulOutcome->procedureCode == ProcedureCode_id_RICcontrol
906 && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICcontrolAcknowledge)
908 RICcontrolAcknowledge_t *controlAck = &(successfulOutcome->value.choice.RICcontrolAcknowledge);
909 RICControlAcknowledge *msg = (RICControlAcknowledge *)calloc(1, sizeof(RICControlAcknowledge));
911 for (i; i < controlAck->protocolIEs.list.count; ++i )
913 if(controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
915 msg->requestorID = controlAck->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
916 msg->instanceID = controlAck->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
918 else if (controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
919 msg->ranfunctionID = controlAck->protocolIEs.list.array[i]->value.choice.RANfunctionID;
921 else if(controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcallProcessID) {
922 size_t callProcessIDSize = controlAck->protocolIEs.list.array[i]->value.choice.RICcallProcessID.size;
923 msg->callProcessID = calloc(1, callProcessIDSize);
924 if (!msg->callProcessID) {
925 fprintf(stderr, "alloc RICcallProcessID failed\n");
926 e2ap_free_decoded_ric_control_ack(msg);
927 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
931 memcpy(msg->callProcessID, controlAck->protocolIEs.list.array[i]->value.choice.RICcallProcessID.buf, callProcessIDSize);
932 msg->callProcessIDSize = callProcessIDSize;
934 else if(controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcontrolOutcome) {
935 size_t ricControlOutComeSize = controlAck->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.size;
936 msg->ricControlOutCome = calloc(1, ricControlOutComeSize);
937 if (!msg->ricControlOutCome) {
938 fprintf(stderr, "alloc ricControlOutCome failed\n");
939 e2ap_free_decoded_ric_control_ack(msg);
940 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
944 memcpy(msg->ricControlOutCome, controlAck->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.buf, ricControlOutComeSize);
945 msg->ricControlOutComeSize = ricControlOutComeSize;
949 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
955 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
959 void e2ap_free_decoded_ric_control_ack(RICControlAcknowledge* msg) {
963 if(msg->callProcessID != NULL) {
964 free(msg->callProcessID);
965 msg->callProcessID = NULL;
967 if(msg->ricControlOutCome != NULL) {
968 free(msg->ricControlOutCome);
969 msg->ricControlOutCome = NULL;
975 RICControlFailure* e2ap_decode_ric_control_failure_message(void *buffer, size_t buf_size)
977 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
978 if ( pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
980 UnsuccessfulOutcome_t* unSuccessfulOutcome = pdu->choice.unsuccessfulOutcome;
981 if ( unSuccessfulOutcome->procedureCode == ProcedureCode_id_RICcontrol
982 && unSuccessfulOutcome->value.present == UnsuccessfulOutcome__value_PR_RICcontrolFailure)
984 RICcontrolFailure_t *controlFailure = &(unSuccessfulOutcome->value.choice.RICcontrolFailure);
985 RICControlFailure *msg = (RICControlFailure *)calloc(1, sizeof(RICControlFailure));
987 for (i; i < controlFailure->protocolIEs.list.count; ++i )
989 if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
991 msg->requestorID = controlFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
992 msg->instanceID = controlFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
994 else if (controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
995 msg->ranfunctionID = controlFailure->protocolIEs.list.array[i]->value.choice.RANfunctionID;
997 else if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcallProcessID) {
998 size_t callProcessIDSize = controlFailure->protocolIEs.list.array[i]->value.choice.RICcallProcessID.size;
999 msg->callProcessID = calloc(1, callProcessIDSize);
1000 if (!msg->callProcessID) {
1001 fprintf(stderr, "alloc RICcallProcessID failed\n");
1002 e2ap_free_decoded_ric_control_failure(msg);
1003 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
1007 memcpy(msg->callProcessID, controlFailure->protocolIEs.list.array[i]->value.choice.RICcallProcessID.buf, callProcessIDSize);
1008 msg->callProcessIDSize = callProcessIDSize;
1010 else if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcontrolOutcome) {
1011 msg->causeType = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.present;
1012 if (msg->causeType == Cause_PR_ricRequest) {
1013 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.ricRequest;
1014 } else if (msg->causeType == Cause_PR_ricService) {
1015 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.ricService;
1016 } else if (msg->causeType == Cause_PR_transport) {
1017 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.transport;
1018 } else if (msg->causeType == Cause_PR_protocol) {
1019 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.protocol;
1020 } else if (msg->causeType == Cause_PR_misc) {
1021 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.misc;
1023 msg->causeType == Cause_PR_NOTHING;
1026 else if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcontrolOutcome) {
1027 size_t ricControlOutComeSize = controlFailure->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.size;
1028 msg->ricControlOutCome = calloc(1, ricControlOutComeSize);
1029 if (!msg->ricControlOutCome) {
1030 fprintf(stderr, "alloc ricControlOutCome failed\n");
1031 e2ap_free_decoded_ric_control_failure(msg);
1032 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
1036 memcpy(msg->ricControlOutCome, controlFailure->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.buf, ricControlOutComeSize);
1037 msg->ricControlOutComeSize = ricControlOutComeSize;
1042 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
1049 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
1054 void e2ap_free_decoded_ric_control_failure(RICControlFailure* msg) {
1058 if(msg->callProcessID != NULL) {
1059 free(msg->callProcessID);
1060 msg->callProcessID = NULL;
1062 if(msg->ricControlOutCome != NULL) {
1063 free(msg->ricControlOutCome);
1064 msg->ricControlOutCome = NULL;