2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
23 size_t encode_E2AP_PDU(E2AP_PDU_t* pdu, void* buffer, size_t buf_size)
25 asn_enc_rval_t encode_result;
26 encode_result = aper_encode_to_buffer(&asn_DEF_E2AP_PDU, NULL, pdu, buffer, buf_size);
27 if (encode_result.encoded == -1) {
30 return encode_result.encoded;
33 E2AP_PDU_t* decode_E2AP_PDU(const void* buffer, size_t buf_size)
35 asn_dec_rval_t decode_result;
37 decode_result = aper_decode_complete(NULL, &asn_DEF_E2AP_PDU, (void **)&pdu, buffer, buf_size);
38 if (decode_result.code == RC_OK) {
41 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
46 long e2ap_get_ric_subscription_request_sequence_number(void *buffer, size_t buf_size)
49 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
50 if (pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
52 RICInitiatingMessage_t* initiatingMessage = &pdu->choice.initiatingMessage;
53 if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscription
54 && initiatingMessage->value.present == RICInitiatingMessage__value_PR_RICsubscriptionRequest)
56 RICsubscriptionRequest_t *ric_subscription_request = &(initiatingMessage->value.choice.RICsubscriptionRequest);
57 for (int i = 0; i < ric_subscription_request->protocolIEs.list.count; ++i)
59 if (ric_subscription_request->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
61 long sequence_number = ric_subscription_request->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
62 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
63 return sequence_number;
72 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
76 ssize_t e2ap_set_ric_subscription_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
79 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
80 if (pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
82 RICInitiatingMessage_t* initiatingMessage = &pdu->choice.initiatingMessage;
83 if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscription
84 && initiatingMessage->value.present == RICInitiatingMessage__value_PR_RICsubscriptionRequest)
86 RICsubscriptionRequest_t *ricSubscriptionRequest = &initiatingMessage->value.choice.RICsubscriptionRequest;
87 for (int i = 0; i < ricSubscriptionRequest->protocolIEs.list.count; ++i)
89 if (ricSubscriptionRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
91 ricSubscriptionRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
92 size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
93 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
103 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
107 /* RICsubscriptionResponse */
108 long e2ap_get_ric_subscription_response_sequence_number(void *buffer, size_t buf_size)
111 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
112 if (pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
114 RICSuccessfulOutcome_t* successfulOutcome = &pdu->choice.successfulOutcome;
115 if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscription
116 && successfulOutcome->value.present == RICSuccessfulOutcome__value_PR_RICsubscriptionResponse)
118 RICsubscriptionResponse_t *ricSubscriptionResponse = &successfulOutcome->value.choice.RICsubscriptionResponse;
119 for (int i = 0; i < ricSubscriptionResponse->protocolIEs.list.count; ++i)
121 if (ricSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
123 long sequence_number = ricSubscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
124 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
125 return sequence_number;
134 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
138 ssize_t e2ap_set_ric_subscription_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
141 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
142 if (pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
144 RICSuccessfulOutcome_t* successfulOutcome = &pdu->choice.successfulOutcome;
145 if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscription
146 && successfulOutcome->value.present == RICSuccessfulOutcome__value_PR_RICsubscriptionResponse)
148 RICsubscriptionResponse_t *ricSubscriptionResponse = &successfulOutcome->value.choice.RICsubscriptionResponse;
149 for (int i = 0; i < ricSubscriptionResponse->protocolIEs.list.count; ++i)
151 if (ricSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
153 ricSubscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
154 size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
155 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
165 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
169 /* RICsubscriptionDeleteRequest */
170 long e2ap_get_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size)
173 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
174 if (pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
176 RICInitiatingMessage_t* initiatingMessage = &pdu->choice.initiatingMessage;
177 if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscriptionDelete
178 && initiatingMessage->value.present == RICInitiatingMessage__value_PR_RICsubscriptionDeleteRequest )
180 RICsubscriptionDeleteRequest_t *subscriptionDeleteRequest = &initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
181 for (int i = 0; i < subscriptionDeleteRequest->protocolIEs.list.count; ++i)
183 if (subscriptionDeleteRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
185 long sequence_number = subscriptionDeleteRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
186 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
187 return sequence_number;
196 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
200 ssize_t e2ap_set_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
203 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
204 if (pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
206 RICInitiatingMessage_t* initiatingMessage = &pdu->choice.initiatingMessage;
207 if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscriptionDelete
208 && initiatingMessage->value.present == RICInitiatingMessage__value_PR_RICsubscriptionDeleteRequest )
210 RICsubscriptionDeleteRequest_t* subscriptionDeleteRequest = &initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
211 for (int i = 0; i < subscriptionDeleteRequest->protocolIEs.list.count; ++i)
213 if (subscriptionDeleteRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
215 subscriptionDeleteRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
216 size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
217 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
227 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
231 /* RICsubscriptionDeleteResponse */
232 long e2ap_get_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size)
235 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
236 if (pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
238 RICSuccessfulOutcome_t* successfulOutcome = &pdu->choice.successfulOutcome;
239 if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscriptionDelete
240 && successfulOutcome->value.present == RICSuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse )
242 RICsubscriptionDeleteResponse_t* subscriptionDeleteResponse = &successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
243 for (int i = 0; i < subscriptionDeleteResponse->protocolIEs.list.count; ++i)
245 if (subscriptionDeleteResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
247 long sequence_number = subscriptionDeleteResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
248 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
249 return sequence_number;
258 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
262 ssize_t e2ap_set_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
265 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
266 if (pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
268 RICSuccessfulOutcome_t* successfulOutcome = &pdu->choice.successfulOutcome;
269 if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscriptionDelete
270 && successfulOutcome->value.present == RICSuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse )
272 RICsubscriptionDeleteResponse_t* subscriptionDeleteResponse = &successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
273 for (int i = 0; i < subscriptionDeleteResponse->protocolIEs.list.count; ++i)
275 if (subscriptionDeleteResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
277 subscriptionDeleteResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
278 size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
279 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
289 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
293 // This function is not used currently. Can be deleted if not needed
294 ssize_t e2ap_set_ric_subscription_failure_sequence_number(void *buffer, size_t buf_size, long sequence_number)
297 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
298 if (pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
300 RICUnsuccessfulOutcome_t* unsuccessfulOutcome = &pdu->choice.unsuccessfulOutcome;
301 if (unsuccessfulOutcome->procedureCode == ProcedureCode_id_ricSubscription
302 && unsuccessfulOutcome->value.present == RICUnsuccessfulOutcome__value_PR_RICsubscriptionFailure)
304 RICsubscriptionFailure_t* subscriptionFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
305 for (int i = 0; i < subscriptionFailure->protocolIEs.list.count; ++i)
307 if (subscriptionFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
309 subscriptionFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
310 size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
311 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
321 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
325 long e2ap_get_ric_subscription_failure_sequence_number(void *buffer, size_t buf_size)
328 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
329 if (pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
331 RICUnsuccessfulOutcome_t* unsuccessfulOutcome = &pdu->choice.unsuccessfulOutcome;
332 if (unsuccessfulOutcome->procedureCode == ProcedureCode_id_ricSubscription
333 && unsuccessfulOutcome->value.present == RICUnsuccessfulOutcome__value_PR_RICsubscriptionFailure)
335 RICsubscriptionFailure_t* subscriptionFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionFailure;;
336 for (int i = 0; i < subscriptionFailure->protocolIEs.list.count; ++i)
338 if (subscriptionFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
340 long sequence_number = subscriptionFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
341 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
342 return sequence_number;
351 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
355 // This function is not used currently. Can be deleted if not needed
356 ssize_t e2ap_set_ric_subscription_delete_failure_sequence_number(void *buffer, size_t buf_size, long sequence_number)
359 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
360 if (pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
362 RICUnsuccessfulOutcome_t* unsuccessfulOutcome = &pdu->choice.unsuccessfulOutcome;
363 if (unsuccessfulOutcome->procedureCode == ProcedureCode_id_ricSubscriptionDelete
364 && unsuccessfulOutcome->value.present == RICUnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure)
366 RICsubscriptionDeleteFailure_t* subscriptionDeleteFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
367 for (int i = 0; i < subscriptionDeleteFailure->protocolIEs.list.count; ++i)
369 if (subscriptionDeleteFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
371 subscriptionDeleteFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
372 size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
373 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
383 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
387 long e2ap_get_ric_subscription_delete_failure_sequence_number(void *buffer, size_t buf_size)
390 E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
391 if (pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
393 RICUnsuccessfulOutcome_t* unsuccessfulOutcome = &pdu->choice.unsuccessfulOutcome;
394 if (unsuccessfulOutcome->procedureCode == ProcedureCode_id_ricSubscriptionDelete
395 && unsuccessfulOutcome->value.present == RICUnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure)
397 RICsubscriptionDeleteFailure_t* subscriptionDeleteFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;;
398 for (int i = 0; i < subscriptionDeleteFailure->protocolIEs.list.count; ++i)
400 if (subscriptionDeleteFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
402 long sequence_number = subscriptionDeleteFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
403 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
404 return sequence_number;
413 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);