1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
18 #include "common_def.h"
24 #include "du_app_mac_inf.h"
25 #include "du_app_rlc_inf.h"
26 #include "du_e2ap_mgr.h"
27 #include "du_e2ap_msg_hdl.h"
31 #include "du_mgr_main.h"
32 #include "du_msg_hdl.h"
34 #include "GlobalE2node-gNB-ID.h"
35 #include "ProtocolIE-FieldE2.h"
36 #include "E2setupRequest.h"
37 #include "InitiatingMessageE2.h"
38 #include "SuccessfulOutcomeE2.h"
39 #include "UnsuccessfulOutcomeE2.h"
41 #include "odu_common_codec.h"
42 #include "E2nodeComponentInterfaceF1.h"
43 #include "E2setupRequest.h"
44 #include "du_e2_conversions.h"
45 #include "E2SM-KPM-RANfunction-Description.h"
46 #include "RANfunction-Name.h"
47 #include "RIC-EventTriggerStyle-Item.h"
48 #include "RIC-ReportStyle-Item.h"
49 #include "MeasurementInfo-Action-Item.h"
50 #include "E2SM-KPM-EventTriggerDefinition.h"
51 #include "E2SM-KPM-EventTriggerDefinition-Format1.h"
52 #include "E2SM-KPM-ActionDefinition.h"
53 #include "E2SM-KPM-ActionDefinition-Format1.h"
54 #include "MeasurementInfoItem.h"
55 #include "RANfunctionsIDcause-List.h"
56 #include "MeasurementRecord.h"
57 #include "MeasurementData.h"
58 #include "MeasurementRecordItem.h"
59 #include "MeasurementDataItem.h"
60 #include "E2SM-KPM-IndicationMessage-Format1.h"
61 #include "E2SM-KPM-IndicationMessage.h"
62 #include "E2SM-KPM-IndicationHeader.h"
63 #include "E2SM-KPM-IndicationHeader-Format1.h"
64 #include "LabelInfoItem.h"
67 /*******************************************************************
69 * @brief Fill E2 Failure Cause
73 * Function : fillE2Cause
75 * Functionality: Fill E2 Failure Cause
77 * @params[in] E2 Cause pointer to be filled in
78 * E2 Cause to be filled from
81 ******************************************************************/
82 void fillE2Cause(CauseE2_t *e2Cause, E2FailureCause failureCause)
84 e2Cause->present = failureCause.causeType;
85 switch(e2Cause->present)
87 case CauseE2_PR_ricRequest:
89 e2Cause->choice.ricRequest = failureCause.cause;
92 case CauseE2_PR_ricService:
94 e2Cause->choice.ricService = failureCause.cause;
97 case CauseE2_PR_e2Node:
99 e2Cause->choice.e2Node = failureCause.cause;
102 case CauseE2_PR_transport:
104 e2Cause->choice.transport = failureCause.cause;
107 case CauseE2_PR_protocol:
109 e2Cause->choice.protocol = failureCause.cause;
112 case CauseE2_PR_misc:
114 e2Cause->choice.misc = failureCause.cause;
117 case CauseE2_PR_NOTHING:
123 /*******************************************************************
125 * @brief Printing Type and Cause of failure
129 * Function : printE2ErrorCause
131 * Functionality: Printing Type and Cause of failure
133 * @params[in] E2 Cause
136 ******************************************************************/
137 void printE2ErrorCause(CauseE2_t *cause)
139 switch(cause->present)
141 case CauseE2_PR_ricRequest:
143 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Request", cause->choice.ricRequest);
146 case CauseE2_PR_ricService:
148 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Service", cause->choice.ricService);
151 case CauseE2_PR_e2Node:
153 DU_LOG("Failure_Type [%s] Cause [%ld]", "E2_Node", cause->choice.e2Node);
156 case CauseE2_PR_transport:
158 DU_LOG("Failure_Type [%s] Cause [%ld]", "Transport", cause->choice.transport);
161 case CauseE2_PR_protocol:
163 DU_LOG("Failure_Type [%s] Cause [%ld]", "Protocol", cause->choice.protocol);
166 case CauseE2_PR_misc:
168 DU_LOG("Failure_Type [%s] Cause [%ld]", "Miscellaneous", cause->choice.misc);
173 DU_LOG("Failure_Type and Cause unknown");
179 /*******************************************************************
181 * @brief Deallocate the memory allocated for E2 Removal Failure
185 * Function : FreeE2RemovalFailure
188 * - freeing the memory allocated for E2RemovalFailure
190 * @params[in] E2AP_PDU_t *e2apMsg
191 * @return ROK - success
194 * ****************************************************************/
195 void FreeE2RemovalFailure(E2AP_PDU_t *e2apMsg)
198 E2RemovalFailure_t *e2RemovalFailure=NULLP;
202 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
204 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
205 if(e2RemovalFailure->protocolIEs.list.array)
207 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
209 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
211 DU_FREE(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
214 DU_FREE(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
216 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
218 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
222 /*******************************************************************
224 * @brief Buld and send the E2 Removal Failure msg
228 * Function : BuildAndSendE2RemovalFailure
231 * - Buld and send the E2 Removal Failure Message
232 * @params[in] Trans Id
233 * @return ROK - success
236 * ****************************************************************/
238 uint8_t BuildAndSendRemovalFailure(uint16_t transId, E2FailureCause failureCause)
240 uint8_t ieIdx = 0, elementCnt = 0;
241 uint8_t ret = RFAILED;
242 E2AP_PDU_t *e2apMsg = NULLP;
243 E2RemovalFailure_t *e2RemovalFailure=NULLP;
244 asn_enc_rval_t encRetVal; /* Encoder return value */
246 DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
249 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
252 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
255 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
257 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
258 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
260 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
264 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
265 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
266 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure;
267 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
270 e2RemovalFailure->protocolIEs.list.count = elementCnt;
271 e2RemovalFailure->protocolIEs.list.size = elementCnt * sizeof(E2RemovalFailureIEs_t *);
272 DU_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
273 if(!e2RemovalFailure->protocolIEs.list.array)
275 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
279 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
281 DU_ALLOC(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
282 if(!e2RemovalFailure->protocolIEs.list.array[ieIdx])
284 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
288 if(ieIdx < elementCnt)
292 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
293 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
294 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = E2RemovalFailureIEs__value_PR_TransactionID;
295 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
299 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
300 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
301 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
302 fillE2Cause(&e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, failureCause);
304 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
306 memset(encBuf, 0, ENC_BUF_MAX_LEN);
308 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
309 if(encRetVal.encoded == ENCODE_FAIL)
311 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
312 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
317 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
318 for(int i=0; i< encBufSize; i++)
320 DU_LOG("%x",encBuf[i]);
325 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
327 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Failure");
335 FreeE2RemovalFailure(e2apMsg);
339 /*******************************************************************
341 * @brief Deallocate the memory allocated for E2 Removal Response
345 * Function : FreeE2RemovalResponse
348 * - freeing the memory allocated for E2RemovalResponse
350 * @params[in] E2AP_PDU_t *e2apMsg
351 * @return ROK - success
354 * ****************************************************************/
355 void FreeE2RemovalResponse(E2AP_PDU_t *e2apMsg)
358 E2RemovalResponse_t *e2RemovalResponse=NULLP;
362 if(e2apMsg->choice.successfulOutcome != NULLP)
364 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
365 if(e2RemovalResponse->protocolIEs.list.array)
367 for(ieIdx=0; ieIdx < e2RemovalResponse->protocolIEs.list.count; ieIdx++)
369 if(e2RemovalResponse->protocolIEs.list.array[ieIdx])
371 DU_FREE(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
374 DU_FREE(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
376 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
378 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
382 /*******************************************************************
384 * @brief Buld and send the E2 Removal Response msg
388 * Function : BuildAndSendE2RemovalResponse
391 * - Buld and send the E2 Removal Response Message
392 * @params[in] Trans Id
393 * @return ROK - success
396 * ****************************************************************/
397 uint8_t BuildAndSendRemovalResponse(uint16_t transId)
399 uint8_t ieIdx = 0, elementCnt = 0;
400 uint8_t ret = RFAILED;
401 E2AP_PDU_t *e2apMsg = NULLP;
402 E2RemovalResponse_t *e2RemovalResponse=NULLP;
403 asn_enc_rval_t encRetVal; /* Encoder return value */
405 DU_LOG("\nINFO --> E2AP : Building E2 Removal Response Message\n");
408 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
411 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
414 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
416 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
417 if(e2apMsg->choice.successfulOutcome == NULLP)
419 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
423 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
424 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
425 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2RemovalResponse;
426 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
429 e2RemovalResponse->protocolIEs.list.count = elementCnt;
430 e2RemovalResponse->protocolIEs.list.size = elementCnt * sizeof(E2RemovalResponseIEs_t *);
431 DU_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
432 if(!e2RemovalResponse->protocolIEs.list.array)
434 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
438 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
440 DU_ALLOC(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
441 if(!e2RemovalResponse->protocolIEs.list.array[ieIdx])
443 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
447 if(ieIdx < elementCnt)
451 e2RemovalResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
452 e2RemovalResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
453 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.present = E2RemovalResponseIEs__value_PR_TransactionID;
454 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
456 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
458 memset(encBuf, 0, ENC_BUF_MAX_LEN);
460 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
461 if(encRetVal.encoded == ENCODE_FAIL)
463 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
464 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
469 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
470 for(int i=0; i< encBufSize; i++)
472 DU_LOG("%x",encBuf[i]);
477 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
479 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Response");
487 FreeE2RemovalResponse(e2apMsg);
491 /******************************************************************
493 * @brief Deallocation of memory allocated by aper decoder for Removal req
497 * Function : freeAperDecodingOfE2RemovalReq
499 * Functionality: Deallocation of memory allocated by aper decoder for
502 * @params[in] Pointer to removalReq
505 * ****************************************************************/
506 void freeAperDecodingOfE2RemovalReq(E2RemovalRequest_t *removalReq)
512 if(removalReq->protocolIEs.list.array)
514 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
516 if(removalReq->protocolIEs.list.array[arrIdx])
518 free(removalReq->protocolIEs.list.array[arrIdx]);
521 free(removalReq->protocolIEs.list.array);
526 /*******************************************************************
528 * @brief Process Removal req received from RIC
532 * Function : procE2RemovalRequest
534 * Functionality: Process Removal req received from RIC
536 * @param E2AP_PDU_t *e2apMsg
539 ******************************************************************/
541 void procE2RemovalRequest(E2AP_PDU_t *e2apMsg)
545 E2FailureCause failureCause;
546 E2RemovalRequest_t *removalReq=NULLP;
548 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
549 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
551 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
553 switch(removalReq->protocolIEs.list.array[arrIdx]->id)
555 case ProtocolIE_IDE2_id_TransactionID:
557 transId = removalReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
562 DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
568 if(transId>=0 && transId<=255)
570 if(BuildAndSendRemovalResponse(transId) != ROK)
572 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
577 failureCause.causeType = E2_PROTOCOL;
578 failureCause.cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
580 if(BuildAndSendRemovalFailure(transId, failureCause) != ROK)
582 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
585 freeAperDecodingOfE2RemovalReq(removalReq);
588 /*******************************************************************
590 * @brief Free the ErrorIndication Message
594 * Function : FreeRicIndication
596 * Functionality: Free the ErrorIndication Message
599 * E2AP_PDU is to freed
602 ******************************************************************/
603 void FreeErrorIndication(E2AP_PDU_t *e2apMsg)
606 ErrorIndicationE2_t *errorIndicationMsg= NULLP;
610 if(e2apMsg->choice.initiatingMessage != NULLP)
612 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
613 if(errorIndicationMsg!= NULLP)
615 if(errorIndicationMsg->protocolIEs.list.array != NULLP)
617 for(arrIdx=0; arrIdx<errorIndicationMsg->protocolIEs.list.count; arrIdx++)
619 DU_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t));
621 DU_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size);
624 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
626 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
630 /*******************************************************************
632 * @brief Builds and Send the ErrorIndication Message
636 * Function : BuildAndSendErrorIndication
638 * Functionality:Fills the ErrorIndication Message
645 * @return ROK - success
648 ******************************************************************/
650 uint8_t BuildAndSendErrorIndication(uint16_t transId, RicRequestId requestId, uint16_t ranFuncId, E2FailureCause failureCause)
652 uint8_t elementCnt =0, arrIdx=0, ret = RFAILED;
653 E2AP_PDU_t *e2apMsg = NULLP;
654 ErrorIndicationE2_t *errorIndicationMsg=NULLP;
655 asn_enc_rval_t encRetVal; /* Encoder return value */
659 DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
661 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
664 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
668 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
669 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
670 if(e2apMsg->choice.initiatingMessage == NULLP)
672 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
675 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
676 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
677 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2;
679 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
681 /* Element count is 2 for TransactionID/RICrequestID and Cause.
682 * If the RAN function id is present, the count will be increased.*/
689 errorIndicationMsg->protocolIEs.list.count = elementCnt;
690 errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*);
692 /* Initialize the E2Setup members */
693 DU_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
694 if(errorIndicationMsg->protocolIEs.list.array == NULLP)
696 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
700 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
702 DU_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
703 if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
705 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array [%d] elements in %s at line %d", arrIdx, __func__, __LINE__);
709 if(arrIdx < elementCnt)
714 if(transId >=0 && transId<=255)
717 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
718 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
719 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID;
720 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
725 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID;
726 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
727 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID;
728 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId;
729 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
734 /* RAN Function ID */
736 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID;
737 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
738 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID;
739 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId;
744 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
745 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
746 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
747 fillE2Cause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, failureCause);
749 /* Prints the Msg formed */
750 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
751 memset(encBuf, 0, ENC_BUF_MAX_LEN);
753 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
755 if(encRetVal.encoded == ENCODE_FAIL)
757 DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
758 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
763 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
764 #ifdef DEBUG_ASN_PRINT
765 for(int i=0; i< encBufSize; i++)
767 printf("%x",encBuf[i]);
772 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
774 DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
780 FreeErrorIndication(e2apMsg);
784 /******************************************************************
786 * @brief Deallocation of memory allocated by aper decoder for e2
787 * Config Update Failure
791 * Function : freeAperDecodingOfE2Node Config UpdateFailure
793 * Functionality: Deallocation of memory allocated by aper decoder
794 * for e2 Config Update Failure
796 * @params[in] E2nodeConfigurationUpdateFailure_t to be deallocated
799 * ****************************************************************/
801 void freeAperDecodingOfE2NodeConfigUpdateFailure(E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail)
807 if(e2NodeCfgUpdFail->protocolIEs.list.array)
809 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
811 if(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx])
813 free(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]);
816 free(e2NodeCfgUpdFail->protocolIEs.list.array);
821 /******************************************************************
823 * @brief Processes E2 Node Config Update Failure sent by RIC
827 * Function : procE2NodeConfigUpdateFailure
829 * Functionality: Processes E2 Node Config Update failure sent by RIC
831 * @params[in] E2AP_PDU_t ASN decoded E2AP message
832 * @return ROK - success
835 * ****************************************************************/
837 void procE2NodeConfigUpdateFailure(E2AP_PDU_t *e2apMsg)
839 uint8_t arrIdx =0, timerValue=0;
841 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
843 DU_LOG("\nINFO --> E2AP : E2 Node Config Update failure received");
844 e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
846 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
848 switch(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->id)
850 case ProtocolIE_IDE2_id_TransactionID:
852 transId = e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
853 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
854 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
856 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
860 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
864 case ProtocolIE_IDE2_id_TimeToWaitE2:
866 timerValue = convertE2WaitTimerEnumToValue(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
867 if((duChkTmr((PTR)&(duCb.e2apDb), EVENT_E2_NODE_CONFIG_UPDATE_TMR)) == FALSE)
869 duStartTmr((PTR)&(duCb.e2apDb), EVENT_E2_NODE_CONFIG_UPDATE_TMR, timerValue);
873 DU_LOG("\nERROR --> E2AP : EVENT_E2_NODE_CONFIG_UPDATE_TMR timer is already running");
880 freeAperDecodingOfE2NodeConfigUpdateFailure(e2NodeCfgUpdFail);
883 /*******************************************************************
885 * @brief Builds Global gNodeB Params
889 * Function : BuildGlobalgNBId
891 * Functionality: Building the Plmn and gNB id
893 * @params[in] GlobalE2node_gNB_ID_t *gNbId
894 * @return ROK - success
897 ******************************************************************/
899 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
902 uint8_t byteSize = 4;
903 uint8_t gnbId = duCb.gnbId;
906 /* fill Global gNB ID Id */
907 gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
908 gNbId->global_gNB_ID.plmn_id.buf = NULLP;
909 DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
910 if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
912 DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
917 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
918 gNbId->global_gNB_ID.plmn_id.buf);
919 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
920 /* Allocate Buffer size */
921 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
922 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
923 DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
924 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
925 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
927 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
932 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId);
937 DU_ALLOC( gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
938 if(gNbId->gNB_DU_ID == NULLP)
940 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID ");
945 gNbId->gNB_DU_ID->size = sizeof(uint8_t);
946 DU_ALLOC( gNbId->gNB_DU_ID->buf, sizeof(uint8_t));
947 if(gNbId->gNB_DU_ID->buf)
949 gNbId->gNB_DU_ID->buf[0] =duCb.e2apDb.e2NodeId;
953 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID buffer");
961 /*******************************************************************
963 * @brief fill the E2 node config information
967 * Function : fillE2NodeConfig
969 * Functionality: fill E2 node config information
972 * Pointer to e2NodeCfg to be filled
973 * E2 Node Component information
974 * Type of configuration
975 * @return ROK - success
978 ******************************************************************/
980 uint8_t fillE2NodeConfig(PTR e2NodeCfg, E2NodeComponent *e2NodeComponentInfo, ConfigType configType)
982 E2NodeConfig *e2NodeConfig=NULLP;
983 E2nodeComponentInterfaceType_t *interfaceType=NULLP;
984 E2nodeComponentID_t *componentID =NULLP;
985 E2nodeComponentConfiguration_t *configuration=NULLP;
986 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
987 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULL;
988 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
994 e2NodeAddItem = (E2nodeComponentConfigAddition_Item_t*)e2NodeCfg;
995 interfaceType = &e2NodeAddItem->e2nodeComponentInterfaceType;
996 componentID = &e2NodeAddItem->e2nodeComponentID;
997 configuration = &e2NodeAddItem->e2nodeComponentConfiguration;
998 e2NodeConfig = e2NodeComponentInfo->addConfiguration;
1003 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_Item_t *) e2NodeCfg;
1004 interfaceType = &e2NodeUpdateItem->e2nodeComponentInterfaceType;
1005 componentID = &e2NodeUpdateItem->e2nodeComponentID;
1006 configuration = &e2NodeUpdateItem->e2nodeComponentConfiguration;
1007 e2NodeConfig = e2NodeComponentInfo->updateConfiguration;
1012 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_Item_t*) e2NodeCfg;
1013 interfaceType = &e2NodeRemovalItem->e2nodeComponentInterfaceType;
1014 componentID = &e2NodeRemovalItem->e2nodeComponentID;
1019 DU_LOG("\nERROR --> E2AP : Configuration type %d does not supported ", configType);
1023 /* E2nodeComponentInterfaceType */
1024 *interfaceType = convertInterfaceToE2ComponentInterfaceType(e2NodeComponentInfo->interfaceType);
1026 /* We now only support the F1 interface out of these interfaces
1027 * (NG,XN,E1,F1,W1,S1,X2), therefore only the F1 component identifier was filled in. */
1029 if(*interfaceType == F1)
1031 /* E2 Node Component ID */
1032 componentID->present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
1033 DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1,sizeof(E2nodeComponentInterfaceF1_t));
1034 if(componentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
1036 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1039 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
1040 DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
1041 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1043 if(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
1045 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1048 memcpy(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, &e2NodeComponentInfo->componentId,\
1049 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1052 if(configType == CONFIG_DEL)
1054 /* We don't need to fill out the E2 Node Component Request and Response
1055 * information in the case of CONFIG_DEL, therefore returning ROK from here. */
1059 /* E2 Node Component Request Part */
1060 if(e2NodeConfig->componentRequestPart)
1062 configuration->e2nodeComponentRequestPart.size = e2NodeConfig->reqBufSize ;
1063 DU_ALLOC(configuration->e2nodeComponentRequestPart.buf,\
1064 configuration->e2nodeComponentRequestPart.size);
1065 if(configuration->e2nodeComponentRequestPart.buf == NULLP)
1067 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1071 memcpy(configuration->e2nodeComponentRequestPart.buf,\
1072 e2NodeConfig->componentRequestPart, configuration->\
1073 e2nodeComponentRequestPart.size);
1077 DU_LOG("\nERROR --> E2AP: componentRequestPart is null ");
1081 /* E2 Node Component Response Part */
1082 if(e2NodeConfig->componentResponsePart)
1084 configuration->e2nodeComponentResponsePart.size = e2NodeConfig->rspBufSize;
1085 DU_ALLOC(configuration->e2nodeComponentResponsePart.buf, configuration->e2nodeComponentResponsePart.size);
1086 if(configuration->e2nodeComponentResponsePart.buf == NULLP)
1088 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1091 memcpy(configuration->e2nodeComponentResponsePart.buf, e2NodeConfig->componentResponsePart, configuration->\
1092 e2nodeComponentResponsePart.size);
1096 DU_LOG("\nERROR --> E2AP: componentResponsePart is null");
1103 /*******************************************************************
1105 * @brief Builds E2 node config addition list
1109 * Function : BuildE2NodeConfigAddList
1111 * Functionality: Building E2 node config addition list
1114 * E2nodeComponentConfigAddition_List_t to be filled
1116 * Count of E2 node to be added in the list
1117 * Received list of E2 node configuration
1119 * @return ROK - success
1122 ******************************************************************/
1124 uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAddList, uint8_t procedureCode, uint16_t count, E2NodeConfigItem *e2NodeList)
1127 CmLList *node =NULL;
1128 E2NodeComponent *e2NodeComponentInfo=NULL;
1129 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe=NULL;
1130 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
1133 /* For ProcedureCodeE2_id_E2setup, the number of E2 node configuration list items is
1134 * equal to the number of E2 node configuration entries stored in the database.
1135 * For any other procedure, the E2 node configuration list count is equal
1136 * to the count of E2 node configuration obtained from the function's caller */
1138 if(procedureCode == ProcedureCodeE2_id_E2setup)
1139 e2NodeAddList->list.count = duCb.e2apDb.e2NodeComponentList.count;
1141 e2NodeAddList->list.count = count;
1143 e2NodeAddList->list.size = e2NodeAddList->list.count * sizeof(E2nodeComponentConfigAddition_ItemIEs_t *);
1144 DU_ALLOC(e2NodeAddList->list.array, e2NodeAddList->list.size);
1145 if(e2NodeAddList->list.array == NULLP)
1147 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
1151 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
1153 DU_ALLOC(e2NodeAddList->list.array[arrIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
1154 if(e2NodeAddList->list.array[arrIdx] == NULLP)
1156 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
1160 if(procedureCode == ProcedureCodeE2_id_E2setup)
1162 /* Getting all of the E2 node configuration's information from DuCb one by one*/
1165 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
1173 DU_LOG("\nERROR --> E2AP : E2 node component list node is null");
1176 e2NodeComponentInfo = (E2NodeComponent*)node->node;
1180 /* Getting only those E2 node configuration from DuCb whose interface
1181 * and action type is present in the received array */
1182 e2NodeComponentInfo = fetchE2NodeComponentInfo(e2NodeList[arrIdx].interface, e2NodeList[arrIdx].componentId, &node);
1185 if(!e2NodeComponentInfo)
1187 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1191 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
1192 e2NodeAddItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition_Item;
1193 e2NodeAddItemIe->criticality = CriticalityE2_reject;
1194 e2NodeAddItemIe->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
1195 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
1196 if(fillE2NodeConfig((PTR)e2NodeAddItem, e2NodeComponentInfo, CONFIG_ADD) != ROK)
1198 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1205 /*******************************************************************
1207 * @brief Builds E2 node config update list
1211 * Function : BuildE2NodeConfigUpdateList
1213 * Functionality: Building E2 node config update list
1216 * E2nodeComponentConfigUpdate_List_t to be filled
1217 * Count of E2 node to be update in the list
1218 * Received list of E2 node configuration
1220 * @return ROK - success
1223 ******************************************************************/
1225 uint8_t BuildE2NodeConfigUpdateList(E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList, uint16_t count, E2NodeConfigItem *updateE2Node)
1228 CmLList *node =NULL;
1229 E2NodeComponent *e2NodeComponentInfo =NULL;
1230 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe =NULL;
1231 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULL;
1233 e2NodeUpdateList->list.count = count;
1234 e2NodeUpdateList->list.size = e2NodeUpdateList->list.count * sizeof(E2nodeComponentConfigUpdate_ItemIEs_t *);
1235 DU_ALLOC(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
1236 if(e2NodeUpdateList->list.array == NULLP)
1238 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
1242 for(arrIdx = 0; arrIdx< e2NodeUpdateList->list.count; arrIdx++)
1244 DU_ALLOC(e2NodeUpdateList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
1245 if(e2NodeUpdateList->list.array[arrIdx] == NULLP)
1247 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
1251 e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface, updateE2Node[arrIdx].componentId, &node);
1252 if(!e2NodeComponentInfo)
1254 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1258 e2NodeUpdateItemIe = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[arrIdx];
1259 e2NodeUpdateItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate_Item;
1260 e2NodeUpdateItemIe->criticality = CriticalityE2_reject;
1261 e2NodeUpdateItemIe->value.present = E2nodeComponentConfigUpdate_ItemIEs__value_PR_E2nodeComponentConfigUpdate_Item;
1262 e2NodeUpdateItem = &e2NodeUpdateItemIe->value.choice.E2nodeComponentConfigUpdate_Item;
1264 if(fillE2NodeConfig((PTR)e2NodeUpdateItem, e2NodeComponentInfo, CONFIG_MOD) != ROK)
1266 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1276 /*******************************************************************
1278 * @brief Builds E2 node config remove list
1282 * Function :BuildE2NodeConfigRemoveList
1284 * Functionality: Building E2 node config remove list
1287 * E2nodeComponentConfigRemoval_List_t to be filled
1288 * Count of E2 node to be remove in the list
1289 * Received list of E2 node configuration
1290 * @return ROK - success
1293 ******************************************************************/
1295 uint8_t BuildE2NodeConfigRemoveList(E2nodeComponentConfigRemoval_List_t *e2NodeRemoveList, uint16_t count, E2NodeConfigItem *updateE2Node)
1299 E2NodeComponent *e2NodeComponentInfo=NULL;
1300 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItemIe=NULL;
1301 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
1303 e2NodeRemoveList->list.count = count;
1304 e2NodeRemoveList->list.size = e2NodeRemoveList->list.count * sizeof(E2nodeComponentConfigRemoval_ItemIEs_t *);
1305 DU_ALLOC(e2NodeRemoveList->list.array, e2NodeRemoveList->list.size);
1306 if(e2NodeRemoveList->list.array == NULLP)
1308 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
1312 for(arrIdx = 0; arrIdx< e2NodeRemoveList->list.count; arrIdx++)
1314 DU_ALLOC(e2NodeRemoveList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
1315 if(e2NodeRemoveList->list.array[arrIdx] == NULLP)
1317 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
1321 e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface,updateE2Node[arrIdx].componentId, &node);
1322 if(!e2NodeComponentInfo)
1324 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1328 e2NodeRemovalItemIe = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemoveList->list.array[arrIdx];
1329 e2NodeRemovalItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval_Item;
1330 e2NodeRemovalItemIe->criticality = CriticalityE2_reject;
1331 e2NodeRemovalItemIe->value.present = E2nodeComponentConfigRemoval_ItemIEs__value_PR_E2nodeComponentConfigRemoval_Item;
1332 e2NodeRemovalItem = &e2NodeRemovalItemIe->value.choice.E2nodeComponentConfigRemoval_Item;
1334 if(fillE2NodeConfig((PTR)e2NodeRemovalItem, e2NodeComponentInfo, CONFIG_DEL) != ROK)
1336 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1343 /*******************************************************************
1345 * @brief deallocation of E2SM_KPM_RANfunction_Description_t
1349 * Function : freeE2smKpmRanFunctionDefinition
1351 * Functionality: deallocation of E2SM_KPM_RANfunction_Description_t
1353 * @params[in] E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition
1356 ******************************************************************/
1358 void freeE2smKpmRanFunctionDefinition(E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition)
1360 MeasurementInfo_Action_Item_t *measInfoList;
1361 uint8_t eventTriggerIdx, reportStyleIdx, measInfoIdx;
1362 RANfunction_Name_t *ranFuncName;
1363 struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle;
1364 struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *eventTriggerStyle;
1365 if(ranFunctionDefinition)
1367 ranFuncName = &ranFunctionDefinition->ranFunction_Name;
1368 /* Free RAN function Name */
1369 DU_FREE(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
1370 DU_FREE(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
1371 DU_FREE(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
1373 /* Sequence of Event Trigger styles */
1374 eventTriggerStyle = ranFunctionDefinition->ric_EventTriggerStyle_List;
1375 if(eventTriggerStyle)
1377 if(eventTriggerStyle->list.array)
1379 for(eventTriggerIdx =0;eventTriggerIdx<eventTriggerStyle->list.count; eventTriggerIdx++)
1381 if(eventTriggerStyle->list.array[eventTriggerIdx])
1383 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.buf,\
1384 eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.size);
1385 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
1388 DU_FREE(eventTriggerStyle->list.array, eventTriggerStyle->list.size)
1390 DU_FREE(eventTriggerStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
1393 /* Sequence of Report styles */
1394 ricReportStyle = ranFunctionDefinition->ric_ReportStyle_List;
1397 if(ricReportStyle->list.array)
1399 for(reportStyleIdx =0;reportStyleIdx<ricReportStyle->list.count; reportStyleIdx++)
1401 if(ricReportStyle->list.array[reportStyleIdx])
1403 if(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf)
1405 DU_FREE(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf,\
1406 ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.size);
1408 if(ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array)
1410 for(measInfoIdx=0; measInfoIdx<ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.count; \
1413 measInfoList = ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array[measInfoIdx];
1416 DU_FREE(measInfoList->measID, sizeof(long));
1417 DU_FREE(measInfoList->measName.buf, measInfoList->measName.size);
1418 DU_FREE(measInfoList,sizeof(MeasurementInfo_Action_Item_t));
1420 DU_FREE(measInfoList, sizeof(MeasurementInfo_Action_Item_t));
1422 DU_FREE(ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array\
1423 ,ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.size);
1425 DU_FREE(ricReportStyle->list.array[reportStyleIdx], sizeof(RIC_ReportStyle_Item_t));
1428 DU_FREE(ricReportStyle->list.array, ricReportStyle->list.size);
1430 DU_FREE(ricReportStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1432 DU_FREE(ranFunctionDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1436 /*******************************************************************
1438 * @brief fill the e2sm ric report style
1442 * Function : fillRicReportStyle
1444 * Functionality: fill the report style
1446 * @params[in] RanFunction *ranFuncDb, struct
1447 * E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle
1448 * @return ROK - success
1451 ******************************************************************/
1452 uint8_t fillRicReportStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle)
1454 uint8_t styleIdx, measInfoIdx;
1455 MeasurementInfo_Action_List_t *measInfo;
1458 ricReportStyle->list.count = ranFuncDb->numOfReportStyleSupported;
1459 ricReportStyle->list.size = ricReportStyle->list.count * sizeof(RIC_ReportStyle_Item_t*);
1460 DU_ALLOC(ricReportStyle->list.array, ricReportStyle->list.size);
1461 if(!ricReportStyle->list.array)
1463 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__);
1467 for(styleIdx =0;styleIdx<ricReportStyle->list.count; styleIdx++)
1469 DU_ALLOC(ricReportStyle->list.array[styleIdx], sizeof(RIC_ReportStyle_Item_t));
1470 if(!ricReportStyle->list.array[styleIdx])
1472 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1476 /* RIC Report Style Type */
1477 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType;
1479 /* RIC Report Style Format Type */
1480 ricReportStyle->list.array[styleIdx]->ric_ActionFormat_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType;
1482 /* RIC Report Style Name */
1483 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size = strlen(ranFuncDb->reportStyleList[styleIdx].reportStyle.name);
1484 DU_ALLOC(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf,\
1485 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1486 if(!ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf)
1488 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1491 memcpy(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf, ranFuncDb->reportStyleList[styleIdx].reportStyle.name,\
1492 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1494 /* RIC Indication Header Format Type*/
1495 ricReportStyle->list.array[styleIdx]->ric_IndicationHeaderFormat_Type = ranFuncDb->ricIndicationHeaderFormat;
1497 /* RIC Indication Message Format Type*/
1498 ricReportStyle->list.array[styleIdx]->ric_IndicationMessageFormat_Type = ranFuncDb->ricIndicationMessageFormat;
1500 /* Measurement Info Action List */
1501 CmLListCp measInfoList =ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
1502 if(!measInfoList.count)
1507 CM_LLIST_FIRST_NODE(&ranFuncDb->reportStyleList[styleIdx].measurementInfoList, node);
1508 measInfo = &ricReportStyle->list.array[styleIdx]->measInfo_Action_List;
1510 measInfo->list.count = measInfoList.count;
1511 measInfo->list.size = measInfoList.count*sizeof(MeasurementInfo_Action_Item_t*);
1512 DU_ALLOC(measInfo->list.array, measInfo->list.size);
1513 if(!measInfo->list.array)
1515 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1519 for(measInfoIdx=0; measInfoIdx<measInfo->list.count; measInfoIdx++)
1523 DU_LOG("\nERROR --> E2AP: Measurement info node is null");
1527 DU_ALLOC(measInfo->list.array[measInfoIdx],sizeof(MeasurementInfo_Action_Item_t));
1528 if(!measInfo->list.array[measInfoIdx])
1530 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1533 MeasurementInfoForAction *measInfoForAction= (MeasurementInfoForAction*)node->node;
1534 DU_ALLOC(measInfo->list.array[measInfoIdx]->measID, sizeof(long));
1535 if(!measInfo->list.array[measInfoIdx]->measID)
1537 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1541 memcpy(measInfo->list.array[measInfoIdx]->measID, &measInfoForAction->measurementTypeId,sizeof(long));
1542 measInfo->list.array[measInfoIdx]->measName.size= strlen(measInfoForAction->measurementTypeName);
1543 DU_ALLOC(measInfo->list.array[measInfoIdx]->measName.buf, measInfo->list.array[measInfoIdx]->measName.size);
1544 if(!measInfo->list.array[measInfoIdx]->measName.size)
1546 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1550 memcpy(measInfo->list.array[measInfoIdx]->measName.buf, \
1551 measInfoForAction->measurementTypeName,\
1552 measInfo->list.array[measInfoIdx]->measName.size);
1559 /*******************************************************************
1561 * @brief fill the ric event trigger style
1565 * Function : fillRicEventTriggerStyle
1567 * Functionality: fill the ric event trigger style
1570 * @return ROK - success
1573 ******************************************************************/
1574 uint8_t fillRicEventTriggerStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *ricEventTriggerStyle)
1578 ricEventTriggerStyle->list.count = ranFuncDb->numOfEventTriggerStyleSupported;
1579 ricEventTriggerStyle->list.size = ricEventTriggerStyle->list.count* sizeof(RIC_EventTriggerStyle_Item_t *);
1580 DU_ALLOC(ricEventTriggerStyle->list.array, ricEventTriggerStyle->list.size);
1581 if(!ricEventTriggerStyle->list.array)
1583 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__);
1587 for(styleIdx =0;styleIdx<ricEventTriggerStyle->list.count; styleIdx++)
1589 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
1590 if(!ricEventTriggerStyle->list.array[styleIdx])
1592 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1595 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Type = ranFuncDb->eventTriggerStyleList[styleIdx].styleType;
1597 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerFormat_Type = ranFuncDb->eventTriggerStyleList[styleIdx].formatType;
1599 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size = strlen(ranFuncDb->eventTriggerStyleList[styleIdx].name);
1600 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,\
1601 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1602 if(!ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf)
1604 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1607 memcpy(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,ranFuncDb->eventTriggerStyleList[styleIdx].name,\
1608 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1614 /*******************************************************************
1616 * @brief Builds Ran function item
1620 * Function : BuildRanFunctionItem
1622 * Functionality: Building RAN function item
1625 * RAN function item that has to be filled
1626 * Stored RAN Function information
1627 * @return ROK - success
1630 ******************************************************************/
1632 uint8_t BuildRanFunctionItem(RANfunction_Item_t *ranFuncItem, RanFunction *ranFuncDb)
1634 uint8_t ret =RFAILED;
1635 RANfunctionDefinition_t *ranFunctionDefinition;
1636 RANfunction_Name_t *ranFuncName;
1637 asn_enc_rval_t encRetVal;
1638 E2SM_KPM_RANfunction_Description_t *ranFuncDefinition;
1642 /* RAN function Id*/
1643 ranFuncItem->ranFunctionID = ranFuncDb->id;
1645 /* RAN Function Revision*/
1646 ranFuncItem->ranFunctionRevision = ranFuncDb->revisionCounter;
1648 /* RAN function OID*/
1649 ranFuncItem->ranFunctionOID.size = strlen(ranFuncDb->name.serviceModelOID);
1650 DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size);
1651 if(!ranFuncItem->ranFunctionOID.buf)
1653 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1656 memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size);
1658 /* RAN function Definition */
1659 DU_ALLOC(ranFuncDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1660 if(!ranFuncDefinition)
1662 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1666 /* RAN function Name */
1667 ranFuncName = &ranFuncDefinition->ranFunction_Name;
1669 /* RAN function ShortName */
1670 ranFuncName->ranFunction_ShortName.size = strlen(ranFuncDb->name.shortName);
1671 DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
1672 if(!ranFuncName->ranFunction_ShortName.buf)
1674 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1677 memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName));
1679 /* RAN function E2SM_OID */
1680 ranFuncName->ranFunction_E2SM_OID.size = strlen(ranFuncDb->name.serviceModelOID);
1681 DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
1682 if(!ranFuncName->ranFunction_E2SM_OID.buf)
1684 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1687 memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
1689 /* RAN Function Name Description */
1690 ranFuncName->ranFunction_Description.size = strlen(ranFuncDb->name.description);
1691 DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
1692 if(!ranFuncName->ranFunction_Description.buf)
1694 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1697 memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size);
1699 /* RIC Event Trigger Style List */
1700 DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
1701 if(!ranFuncDefinition->ric_EventTriggerStyle_List)
1703 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1707 if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
1709 DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
1713 /* RIC Report Style List */
1714 DU_ALLOC(ranFuncDefinition->ric_ReportStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1715 if(!ranFuncDefinition->ric_ReportStyle_List)
1717 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1720 if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
1722 DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
1726 /* Encode the F1SetupRequest type as APER */
1727 xer_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, ranFuncDefinition);
1729 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1731 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_RANfunction_Description, 0, ranFuncDefinition, PrepFinalEncBuf, encBuf);
1733 /* Encode results */
1734 if(encRetVal.encoded == ENCODE_FAIL)
1736 DU_LOG("\nERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\
1737 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1742 DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n");
1743 for(uint8_t measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
1745 printf("%x",encBuf[measIeIdx]);
1747 ranFunctionDefinition = &ranFuncItem->ranFunctionDefinition;
1748 ranFunctionDefinition->size = encBufSize;
1749 DU_ALLOC(ranFunctionDefinition->buf, encBufSize);
1750 if(ranFunctionDefinition->buf == NULLP)
1752 DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
1755 memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize);
1760 freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
1764 /*******************************************************************
1766 * @brief Builds Ran function add list based on the procedure code
1770 * Function : BuildRanFunctionAddList
1772 * Functionality: Building RAN addition addition list
1773 * In case of ProcedureCodeE2_id_E2setup we add all the RAN Function list
1774 * which is present in E2 database.
1775 * In the case of other procedures, we just fill the RAN functions whose ID
1776 * is contained in recvList
1781 * Count of ran functions to be added in the list
1782 * Received list of RAN functions
1784 * @return ROK - success
1787 ******************************************************************/
1789 uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList, uint8_t procedureCode, uint8_t count, RanFuncInfo *recvList)
1792 RanFunction *ranFuncDb;
1794 RANfunction_ItemIEs_t *ranFuncItemIe;
1796 /* For ProcedureCodeE2_id_E2setup, the number of RAN function list items is
1797 * equal to the number of ran function entries stored in the database.
1798 * For any other procedure, the RAN function list count is equal
1799 * to the count of ran functions obtained from the function's caller */
1801 if(procedureCode == ProcedureCodeE2_id_E2setup)
1802 ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
1804 ranFunctionsList->list.count = count;
1806 ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*);
1807 DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
1808 if(ranFunctionsList->list.array == NULLP)
1810 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1814 for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++)
1816 DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1817 if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
1819 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1822 if(procedureCode == ProcedureCodeE2_id_E2setup)
1824 /* Getting all of the RAN function's information from DuCb one by one*/
1825 ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
1829 /* Getting only the RAN function information from DuCb whose Id is
1830 * present in the received array */
1831 id =recvList[ranFuncIdx].id;
1832 ranFuncDb = &duCb.e2apDb.ranFunction[id-1];
1834 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1835 ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item;
1836 ranFuncItemIe->criticality = CriticalityE2_ignore;
1837 ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
1838 BuildRanFunctionItem(&ranFuncItemIe->value.choice.RANfunction_Item, ranFuncDb);
1843 /*******************************************************************
1845 * @brief De Allocate E2 Setup Request Message
1849 * Function : FreeE2SetupReq
1851 * Functionality: De-Allocating E2 Setup request Message
1853 * @params[in] E2AP_PDU_t *e2apMsg
1857 * ****************************************************************/
1859 void FreeE2SetupReq(E2AP_PDU_t *e2apMsg)
1862 uint8_t e2NodeAddListIdx =0, ranFuncAddListIdx;
1863 E2setupRequest_t *e2SetupReq;
1864 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1865 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1866 RANfunctions_List_t *ranFunctionsList;
1867 RANfunction_ItemIEs_t *ranFuncItemIe;
1868 RANfunction_Item_t *ranFunItem;
1870 /* De-allocating Memory */
1871 if(e2apMsg != NULLP)
1873 if(e2apMsg->choice.initiatingMessage != NULLP)
1875 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
1876 if(e2SetupReq->protocolIEs.list.array != NULLP)
1878 for(arrIdx = 0; arrIdx < e2SetupReq->protocolIEs.list.count; arrIdx++)
1880 if(e2SetupReq->protocolIEs.list.array[arrIdx] != NULLP)
1882 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1884 case ProtocolIE_IDE2_id_TransactionID:
1886 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1888 if(e2SetupReq->protocolIEs.list.array[arrIdx]->\
1889 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
1891 GlobalE2node_gNB_ID_t *gNbId = NULLP;
1892 gNbId = e2SetupReq->protocolIEs.list.array[arrIdx]->\
1893 value.choice.GlobalE2node_ID.choice.gNB;
1894 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
1896 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
1897 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
1898 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
1899 gNbId->global_gNB_ID.plmn_id.size);
1902 if(gNbId->gNB_DU_ID != NULLP)
1904 DU_FREE( gNbId->gNB_DU_ID->buf, gNbId->gNB_DU_ID->size);
1905 DU_FREE(gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
1907 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
1908 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
1912 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1914 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1915 if(e2NodeAddList->list.array)
1917 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1919 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
1921 /* Free E2 Node Component Request Part */
1922 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
1923 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
1925 /* Free E2 Node Component Response Part */
1926 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.\
1927 e2nodeComponentResponsePart.buf, \
1928 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
1930 /* Free E2 Node Component ID */
1931 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1)
1933 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1934 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
1935 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1936 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1937 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
1938 sizeof(E2nodeComponentInterfaceF1_t));
1940 DU_FREE(e2NodeAddList->list.array[e2NodeAddListIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
1942 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
1946 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1948 ranFunctionsList = &(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
1949 if(ranFunctionsList->list.array)
1951 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
1953 if(ranFunctionsList->list.array[ranFuncAddListIdx])
1955 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
1956 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1957 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
1958 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
1959 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
1962 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
1968 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
1969 (e2SetupReq->protocolIEs.list.array[arrIdx]->id));
1972 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx], sizeof(E2setupRequestIEs_t));
1975 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
1977 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1979 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1983 /*******************************************************************
1985 * @brief Builds and Send the E2SetupRequest
1989 * Function : BuildAndSendE2SetupReq
1991 * Functionality:Fills the E2SetupRequest
1993 * @return ROK - success
1996 ******************************************************************/
1998 uint8_t BuildAndSendE2SetupReq()
2000 uint16_t transId = 0;
2001 uint8_t arrIdx = 0, elementCnt=0, ret =RFAILED;
2002 bool memAllocFailed = false;
2003 E2AP_PDU_t *e2apMsg = NULLP;
2004 E2setupRequest_t *e2SetupReq = NULLP;
2005 asn_enc_rval_t encRetVal; /* Encoder return value */
2007 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
2010 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2011 if(e2apMsg == NULLP)
2013 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2016 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2017 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2018 if(e2apMsg->choice.initiatingMessage == NULLP)
2020 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2023 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2024 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
2025 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
2026 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
2029 e2SetupReq->protocolIEs.list.count = elementCnt;
2030 e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*);
2032 /* Initialize the E2Setup members */
2033 DU_ALLOC(e2SetupReq->protocolIEs.list.array, \
2034 e2SetupReq->protocolIEs.list.size);
2035 if(e2SetupReq->protocolIEs.list.array == NULLP)
2037 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
2040 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
2042 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx],\
2043 sizeof(E2setupRequestIEs_t));
2044 if(e2SetupReq->protocolIEs.list.array[arrIdx] == NULLP)
2046 memAllocFailed = true;
2047 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
2051 if(memAllocFailed == true)
2057 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2058 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2059 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
2060 transId = assignTransactionId();
2061 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2064 /* GlobalE2node_gNB_ID */
2065 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
2066 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2067 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
2068 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
2070 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
2071 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
2072 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
2073 GlobalE2node_ID.choice.gNB == NULLP)
2075 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
2080 ret = BuildGlobalgNBId(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
2081 choice.GlobalE2node_ID.choice.gNB);
2084 DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
2089 /* RAN Functions Added List */
2091 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
2092 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2093 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
2094 if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
2096 DU_LOG("\nERROR --> E2AP : Failed to create RAN Function");
2100 /* E2 Node Component Configuration Addition List */
2102 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
2103 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2104 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
2105 if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
2107 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
2113 /* Prints the Msg formed */
2114 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2116 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2118 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
2120 if(encRetVal.encoded == ENCODE_FAIL)
2122 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
2123 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2128 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
2129 #ifdef DEBUG_ASN_PRINT
2130 for(int i=0; i< encBufSize; i++)
2132 printf("%x",encBuf[i]);
2136 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2138 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
2143 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
2144 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
2146 FreeE2SetupReq(e2apMsg);
2148 }/* End of BuildAndSendE2SetupReq */
2150 /*******************************************************************
2152 * @brief Builds RIC Action Admitted List
2156 * Function : BuildRicActionAdmitList
2158 * Functionality: Builds RIC Action Admitted List
2160 * @params[in] Pointer to RIC Action Admitted List to be filled
2161 * Subscription Response information
2162 * @return ROK - success
2165 * ****************************************************************/
2166 uint8_t BuildRicActionAdmitList(RICaction_Admitted_List_t *admitList, PendingSubsRspInfo *subsRspInfo)
2169 uint8_t elementCnt = 0;
2170 RICaction_Admitted_ItemIEs_t *admitItem = NULLP;
2172 elementCnt = subsRspInfo->numOfAcceptedActions;
2174 admitList->list.count = elementCnt;
2175 admitList->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t *);
2177 DU_ALLOC(admitList->list.array, admitList->list.size);
2178 if(admitList->list.array == NULLP)
2180 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2184 for(idx=0; idx<elementCnt; idx++)
2186 DU_ALLOC(admitList->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
2187 if(admitList->list.array[idx] == NULLP)
2189 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2193 admitItem = (RICaction_Admitted_ItemIEs_t *)admitList->list.array[idx];
2194 admitItem->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
2195 admitItem->criticality = CriticalityE2_reject;
2196 admitItem->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
2197 admitItem->value.choice.RICaction_Admitted_Item.ricActionID = subsRspInfo->acceptedActionList[idx];
2202 /*******************************************************************
2204 * @brief Builds RIC Action Not Admitted List
2208 * Function : BuildRicActionNotAdmitList
2210 * Functionality: Builds RIC Action Not Admitted List
2212 * @params[in] Pointer to RIC Action Not Admitted List to be filled
2213 * Subscription Response information
2214 * @return ROK - success
2217 * ****************************************************************/
2218 uint8_t BuildRicActionNotAdmitList(RICaction_NotAdmitted_List_t *notAdmitList, PendingSubsRspInfo *subsRspInfo)
2221 uint8_t elementCnt = 0;
2222 RICaction_NotAdmitted_ItemIEs_t *notAdmitItem = NULLP;
2224 elementCnt = subsRspInfo->numOfRejectedActions;
2226 notAdmitList->list.count = elementCnt;
2227 notAdmitList->list.size = elementCnt * sizeof(RICaction_NotAdmitted_ItemIEs_t *);
2229 DU_ALLOC(notAdmitList->list.array, notAdmitList->list.size);
2230 if(notAdmitList->list.array == NULLP)
2232 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2236 for(idx=0; idx<elementCnt; idx++)
2238 DU_ALLOC(notAdmitList->list.array[idx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
2239 if(notAdmitList->list.array[idx] == NULLP)
2241 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2245 notAdmitItem = (RICaction_NotAdmitted_ItemIEs_t *)notAdmitList->list.array[idx];
2246 notAdmitItem->id = ProtocolIE_IDE2_id_RICaction_NotAdmitted_Item;
2247 notAdmitItem->criticality = CriticalityE2_reject;
2248 notAdmitItem->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;
2249 notAdmitItem->value.choice.RICaction_NotAdmitted_Item.ricActionID = \
2250 subsRspInfo->rejectedActionList[idx].id;
2251 fillE2Cause(¬AdmitItem->value.choice.RICaction_NotAdmitted_Item.cause, \
2252 subsRspInfo->rejectedActionList[idx].failureCause);
2257 /*******************************************************************
2259 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
2263 * Function : FreeRicSubscriptionRsp
2265 * Functionality:Free the RicSubscriptionRsp
2267 * @param[in] E2AP_PDU_t *e2apRicMsg
2271 ******************************************************************/
2272 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
2274 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
2277 RICaction_Admitted_List_t *admitList = NULLP;
2278 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
2280 if(e2apRicMsg != NULLP)
2282 if(e2apRicMsg->choice.successfulOutcome != NULLP)
2284 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2285 if(ricSubscriptionRsp)
2287 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
2289 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
2291 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
2293 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
2295 case ProtocolIE_IDE2_id_RICactions_Admitted:
2297 admitList = &ricSubscriptionRsp->protocolIEs.list.\
2298 array[idx]->value.choice.RICaction_Admitted_List;
2299 if(admitList->list.array != NULLP)
2301 for(listIdx=0 ; listIdx < admitList->list.count; listIdx++)
2303 DU_FREE(admitList->list.array[listIdx], sizeof(RICaction_Admitted_ItemIEs_t));
2305 DU_FREE(admitList->list.array, admitList->list.size);
2309 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
2311 notAdmitList = &ricSubscriptionRsp->protocolIEs.list.\
2312 array[idx]->value.choice.RICaction_NotAdmitted_List;
2313 if(notAdmitList->list.array != NULLP)
2315 for(listIdx=0 ; listIdx < notAdmitList->list.count; listIdx++)
2317 DU_FREE(notAdmitList->list.array[listIdx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
2319 DU_FREE(notAdmitList->list.array, notAdmitList->list.size);
2326 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], sizeof(RICsubscriptionResponse_IEs_t));
2329 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
2332 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2334 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
2338 /*******************************************************************
2340 * @brief Fill RIC Subscription Response IEs
2344 * Function : fillRicSubscriptionRsp
2346 * functionality: Fill RIC Subscription Response IEs
2348 * @param Pointer to RIC subscription response
2349 * Subscription response information
2350 * @return ROK - success
2353 ******************************************************************/
2354 uint8_t fillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp, PendingSubsRspInfo *subsRspInfo)
2357 uint8_t elementCnt = 0;
2358 RICsubscriptionResponse_IEs_t *subsRspIe = NULLP;
2361 if(subsRspInfo->numOfRejectedActions)
2364 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
2365 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
2366 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
2367 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
2369 DU_LOG("\nERROR --> E2AP : Memory allocation failed at %s : line %d", __func__, __LINE__);
2373 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
2375 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionResponse_IEs_t));
2376 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx] == NULLP)
2378 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d] : ieIdx [%d]", __func__, __LINE__,ieIdx);
2383 /* RIC Request ID */
2385 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2386 subsRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
2387 subsRspIe->criticality = CriticalityE2_reject;
2388 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
2389 subsRspIe->value.choice.RICrequestID.ricRequestorID = subsRspInfo->requestId.requestorId;
2390 subsRspIe->value.choice.RICrequestID.ricInstanceID = subsRspInfo->requestId.instanceId;
2392 /* RAN Function ID */
2394 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2395 subsRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
2396 subsRspIe->criticality = CriticalityE2_reject;
2397 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
2398 subsRspIe->value.choice.RANfunctionID = subsRspInfo->ranFuncId;
2400 /* RIC Action Admitted List */
2402 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2403 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_Admitted;
2404 subsRspIe->criticality = CriticalityE2_reject;
2405 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
2406 if(BuildRicActionAdmitList(&subsRspIe->value.choice.RICaction_Admitted_List, subsRspInfo) != ROK)
2408 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Admitted List in RIC Subscription Response");
2412 /* RIC Action Not Admitted List */
2413 if(subsRspInfo->numOfRejectedActions)
2416 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2417 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_NotAdmitted;
2418 subsRspIe->criticality = CriticalityE2_reject;
2419 subsRspIe->criticality = CriticalityE2_reject;
2420 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
2421 if(BuildRicActionNotAdmitList(&subsRspIe->value.choice.RICaction_NotAdmitted_List, subsRspInfo) != ROK)
2423 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Not Admitted List in RIC Subscription Response");
2431 /*******************************************************************
2433 * @brief Builds and Send the RicSubscriptionRsp
2437 * Function : BuildAndSendRicSubscriptionRsp
2439 * Functionality:Fills the RicSubscriptionRsp
2441 * @return ROK - success
2444 ******************************************************************/
2446 uint8_t BuildAndSendRicSubscriptionRsp(PendingSubsRspInfo *subsRspInfo)
2448 uint8_t ret = RFAILED;
2449 E2AP_PDU_t *e2apRicMsg = NULLP;
2450 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
2451 asn_enc_rval_t encRetVal;
2455 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
2457 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
2458 if(e2apRicMsg == NULLP)
2460 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2464 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
2465 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2466 if(e2apRicMsg->choice.successfulOutcome == NULLP)
2468 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
2472 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
2473 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2474 e2apRicMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
2476 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2478 if(fillRicSubscriptionRsp(ricSubscriptionRsp, subsRspInfo) != ROK)
2480 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
2484 /* Prints the Msg formed */
2485 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
2487 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2489 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
2490 if(encRetVal.encoded == ENCODE_FAIL)
2492 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
2493 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2498 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
2499 #ifdef DEBUG_ASN_PRINT
2500 for(int i=0; i< encBufSize; i++)
2502 printf("%x",encBuf[i]);
2507 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2509 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
2518 FreeRicSubscriptionRsp(e2apRicMsg);
2522 /******************************************************************
2524 * @brief Deallocation of memory allocated by aper decoder for e2 setup response
2528 * Function : freeAperDecodingOfE2SetupRsp
2530 * Functionality: Deallocation of memory allocated by aper decoder for e2
2533 * @params[in] E2setupResponse_t *e2SetRspMsg;
2536 * ****************************************************************/
2537 void freeAperDecodingOfE2SetupRsp(E2setupResponse_t *e2SetRspMsg)
2539 uint8_t arrIdx, e2NodeConfigAddAckListIdx;
2540 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
2541 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAddAckList;
2545 if(e2SetRspMsg->protocolIEs.list.array)
2547 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2549 if(e2SetRspMsg->protocolIEs.list.array[arrIdx])
2551 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2553 case ProtocolIE_IDE2_id_TransactionID:
2556 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2558 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.pLMN_Identity.buf);
2559 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID.buf);
2563 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2565 e2NodeConfigAddAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2566 if(e2NodeConfigAddAckList->list.array )
2568 for(e2NodeConfigAddAckListIdx = 0; e2NodeConfigAddAckListIdx< e2NodeConfigAddAckList->list.count; e2NodeConfigAddAckListIdx++)
2570 if(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx])
2572 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx];
2573 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2574 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf);
2575 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2576 e2nodeComponentInterfaceTypeF1);
2577 free(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx]);
2580 free(e2NodeConfigAddAckList->list.array);
2585 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]);
2588 free(e2SetRspMsg->protocolIEs.list.array);
2593 /******************************************************************
2595 * @brief handling of e2 noe config update ack ies
2599 * Function :handleE2NodeConfigUpdateAckIes
2601 * Functionality: handling of e2 noe config update ack ies
2604 * Pointer to the E2 Node cfg
2607 ******************************************************************/
2609 void handleE2NodeConfigUpdateAckIes(PTR e2NodeCfg, uint8_t procedureCode)
2611 CmLList *node=NULLP;
2612 E2NodeComponent *e2NodeComponentInfo=NULLP;
2613 E2nodeComponentID_t *e2nodeComponentID=NULLP;
2614 E2nodeComponentConfigRemovalAck_Item_t *removalAckItem=NULLP;
2615 E2nodeComponentConfigUpdateAck_Item_t *updateAckItem=NULLP;
2616 E2nodeComponentConfigAdditionAck_Item_t *additionAckItem=NULLP;
2618 switch(procedureCode)
2620 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2622 additionAckItem = (E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg;
2623 e2nodeComponentID = &additionAckItem->e2nodeComponentID;
2626 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
2628 updateAckItem = (E2nodeComponentConfigUpdateAck_Item_t*) e2NodeCfg;
2629 e2nodeComponentID = &updateAckItem->e2nodeComponentID;
2632 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
2634 removalAckItem= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
2635 e2nodeComponentID = &removalAckItem->e2nodeComponentID;
2640 switch(e2nodeComponentID->present)
2642 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
2644 e2NodeComponentInfo = fetchE2NodeComponentInfo(F1, e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0], &node);
2645 if(!e2NodeComponentInfo)
2647 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
2656 switch(procedureCode)
2658 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2660 DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, e2NodeComponentInfo->addConfiguration->reqBufSize);
2661 DU_FREE(e2NodeComponentInfo->addConfiguration->componentResponsePart, e2NodeComponentInfo->addConfiguration->rspBufSize);
2662 DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
2665 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
2667 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentRequestPart, e2NodeComponentInfo->updateConfiguration->reqBufSize);
2668 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentResponsePart, e2NodeComponentInfo->updateConfiguration->rspBufSize);
2669 DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
2672 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
2674 cmLListDelFrm(&duCb.e2apDb.e2NodeComponentList, node);
2675 if(e2NodeComponentInfo->addConfiguration)
2677 DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, e2NodeComponentInfo->addConfiguration->reqBufSize);
2678 DU_FREE(e2NodeComponentInfo->addConfiguration->componentResponsePart, e2NodeComponentInfo->addConfiguration->rspBufSize);
2679 DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
2681 if(e2NodeComponentInfo->updateConfiguration)
2683 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentRequestPart, e2NodeComponentInfo->updateConfiguration->reqBufSize);
2684 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentResponsePart, e2NodeComponentInfo->updateConfiguration->rspBufSize);
2685 DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
2687 DU_FREE(node, sizeof(CmLList));
2693 /******************************************************************
2695 * @brief Processes E2 Setup Response sent by RIC
2699 * Function : procE2SetupRsp
2701 * Functionality: Processes E2 Setup Response sent by RIC
2703 * @params[in] E2AP_PDU_t ASN decoded E2AP message
2706 * ****************************************************************/
2708 void procE2SetupRsp(E2AP_PDU_t *e2apMsg)
2710 bool invalidTransId = false;
2711 uint8_t arrIdx =0, idx=0;
2713 uint32_t recvBufLen;
2714 E2setupResponse_t *e2SetRspMsg=NULL;
2715 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
2716 RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL;
2717 RANfunctionsIDcause_List_t *ranFuncRejectedList=NULL;
2718 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
2719 E2nodeComponentConfigAdditionAck_List_t *e2NodeCfgAckList=NULL;
2720 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem=NULL;
2722 DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
2723 duCb.e2Status = TRUE; //Set E2 status as true
2724 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
2726 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2728 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2730 case ProtocolIE_IDE2_id_TransactionID:
2732 transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2733 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
2734 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
2736 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
2740 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
2741 invalidTransId = true;
2746 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2748 /* To store the Ric Id Params */
2749 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value\
2750 .choice.GlobalRIC_ID.pLMN_Identity.size);
2751 memcpy(&duCb.e2apDb.ricId.plmnId, e2SetRspMsg->protocolIEs.list.array[arrIdx]\
2752 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
2753 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID, &duCb.e2apDb.ricId);
2754 /*TODO : duCb.e2apDb.ricId.plmnId memory to be deallocated after the usage */
2758 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2760 e2NodeCfgAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2761 for(idx =0; idx <e2NodeCfgAckList->list.count; idx++)
2763 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeCfgAckList->list.array[idx];
2764 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
2765 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
2769 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2771 ranFuncAcceptedList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2772 for(idx =0; idx <ranFuncAcceptedList->list.count; idx++)
2774 ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[idx];
2775 DU_LOG("\nINFO --> E2AP : Ran function id [%ld] accepted",ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID);
2780 case ProtocolIE_IDE2_id_RANfunctionsRejected:
2782 ranFuncRejectedList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
2783 for(idx =0; idx <ranFuncRejectedList->list.count; idx++)
2785 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[idx];
2786 DU_LOG("\nINFO --> E2AP : Ran function id [%ld] rejected",ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID);
2792 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
2793 e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
2798 if(invalidTransId == true)
2803 freeAperDecodingOfE2SetupRsp(e2SetRspMsg);
2805 if(invalidTransId == false)
2807 if(duSendE2NodeConfigurationUpdate() != ROK)
2809 DU_LOG("\nERROR --> E2AP : Failed to send E2 node config update");
2814 /*******************************************************************
2816 * @brief Free RIC Subscription Request
2820 * Function : freeAperDecodingOfRicSubsReq
2822 * Functionality : Free RIC Subscription Request
2826 ******************************************************************/
2827 void freeAperDecodingOfRicSubsReq(RICsubscriptionRequest_t *ricSubscriptionReq)
2830 uint8_t elementIdx = 0;
2831 RICsubscriptionDetails_t *subsDetails = NULLP;
2832 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
2834 if(ricSubscriptionReq->protocolIEs.list.array)
2836 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
2838 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
2840 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
2842 subsDetails = &(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails);
2843 free(subsDetails->ricEventTriggerDefinition.buf);
2845 if(subsDetails->ricAction_ToBeSetup_List.list.array)
2847 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
2849 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
2851 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
2852 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
2854 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf);
2855 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition);
2857 free(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]);
2860 free(subsDetails->ricAction_ToBeSetup_List.list.array);
2865 free(ricSubscriptionReq->protocolIEs.list.array[idx]);
2867 free(ricSubscriptionReq->protocolIEs.list.array);
2871 /*******************************************************************
2873 * @brief Free Event Trigger Definition
2877 * Function : freeAperDecodingOfEventTriggerDef
2879 * Functionality: Free Event Trigger Definition
2881 * @params[in] E2SM-KPM Event Trigger Definition
2884 * ****************************************************************/
2885 void freeAperDecodingOfEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
2889 switch(eventTiggerDef->eventDefinition_formats.present)
2891 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
2894 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
2895 free(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1);
2901 /*******************************************************************
2903 * @brief Extract E2SM-KPM Event trigger definition
2907 * Function : extractEventTriggerDef
2909 * Functionality : This function :
2910 * - Decodes E2SM-KPM Event Trigger Definition
2911 * - Validates that even trigger style is supported by E2 node
2912 * - Stores event trigger details in local DB
2914 * @params[in] RAN Function Database structure
2915 * RIC Subscription Info to be added to RAN function
2916 * RIC Event Trigger Definition buffer received from RIC
2917 * @return ROK - success
2920 ******************************************************************/
2921 uint8_t extractEventTriggerDef(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
2922 RICeventTriggerDefinition_t *ricEventTriggerDef, E2FailureCause *failureCause)
2924 uint8_t ret = RFAILED;
2925 uint8_t eventIdx = 0;
2926 asn_dec_rval_t rval ={0};
2927 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef, *eventTiggerDefPtr = NULLP;
2929 /* Decoding E2SM-KPM Even Trigger Definition */
2930 eventTiggerDefPtr = &eventTiggerDef;
2931 memset(eventTiggerDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
2933 rval = aper_decode(0, &asn_DEF_E2SM_KPM_EventTriggerDefinition, (void **)&eventTiggerDefPtr, ricEventTriggerDef->buf,\
2934 ricEventTriggerDef->size, 0, 0);
2935 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2937 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Event Trigger Definition");
2938 failureCause->causeType = E2_PROTOCOL;
2939 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
2943 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, eventTiggerDefPtr);
2945 /* Validating the received event trigger definition format */
2946 for(eventIdx = 0; eventIdx < ranFuncDb->numOfEventTriggerStyleSupported; eventIdx++)
2948 if((eventTiggerDefPtr->eventDefinition_formats.present != \
2949 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING) && \
2950 (eventTiggerDefPtr->eventDefinition_formats.present == ranFuncDb->eventTriggerStyleList[eventIdx].formatType))
2952 ricSubscriptionInfo->eventTriggerDefinition.formatType = ranFuncDb->eventTriggerStyleList[eventIdx].formatType;
2953 ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod = \
2954 eventTiggerDefPtr->eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod;
2963 failureCause->causeType = E2_RIC_REQUEST;
2964 failureCause->cause = E2_EVENT_TRIGGER_NOT_SUPPORTED;
2966 /* Free E2SM_KPM_EventTriggerDefinition_t */
2967 freeAperDecodingOfEventTriggerDef(eventTiggerDefPtr);
2971 /*******************************************************************
2973 * @brief Free RIC Action Definition
2977 * Function : freeAperDecodingOfRicActionDefinition
2979 * Functionality: Free RIC Action Definition
2981 * @params[in] E2SM-KPM Action definition
2984 * ****************************************************************/
2985 void freeAperDecodingOfRicActionDefinition(E2SM_KPM_ActionDefinition_t *actionDef)
2987 uint8_t elementIdx = 0;
2988 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
2989 MeasurementInfoItem_t *measItem = NULLP;
2991 switch(actionDef->actionDefinition_formats.present)
2993 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
2995 if(actionDef->actionDefinition_formats.choice.actionDefinition_Format1)
2997 actionFormat1 = actionDef->actionDefinition_formats.choice.actionDefinition_Format1;
2998 if(actionFormat1->measInfoList.list.array)
3000 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
3002 if(actionFormat1->measInfoList.list.array[elementIdx])
3004 measItem = actionFormat1->measInfoList.list.array[elementIdx];
3005 switch(measItem->measType.present)
3007 case MeasurementType_PR_NOTHING:
3010 case MeasurementType_PR_measName:
3012 free(measItem->measType.choice.measName.buf);
3016 case MeasurementType_PR_measID:
3022 free(actionFormat1->measInfoList.list.array);
3024 free(actionFormat1);
3028 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
3029 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
3030 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
3031 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
3037 /*******************************************************************
3039 * @brief Extract Measurement Info list from action definition
3043 * Function : extractMeasInfoList
3045 * Functionality : This function :
3046 * - Traverses Measurement-to-be-subscribed list
3047 * - Validates that each measurement in Measurement-to-be-subscribed
3048 * list is supported in RAN-Function->Measurement-supported list.
3049 * - If all measurements in an action is supported by RAN function,
3050 * it is added to measurement-subscribed list in local DB
3052 * @params[in] Measurement Info supported list by RAN function
3053 * Measurement Info to be subscribed as requested by RIC
3054 * Measurement Info finally subscribed
3055 * Memory failure indicator
3056 * @return ROK - success
3059 ******************************************************************/
3060 uint8_t extractMeasInfoList(CmLListCp *measInfoSupportedList, MeasurementInfoList_t *measInfoToBeSubscribedList, \
3061 CmLListCp *measInfoSubscribedList, bool *memFailure)
3063 uint8_t elementIdx = 0;
3064 MeasurementInfoForAction *measInfoSupportedDb = NULLP;
3065 MeasurementInfo *measInfoSubscribedDb = NULLP;
3066 CmLList *supportedMeasNode = NULLP, *measToAddNode = NULLP;
3067 MeasurementInfoItem_t *measItem = NULLP;
3069 /* Validate Measurement list is supported by E2 node.
3071 * Traverse and compare the Measurement-Supported List in E2
3072 * node with Measurement-to-be-subscribed list received from RIC.
3073 * If a match is found, add it to measurement-subscription list.
3075 for(elementIdx = 0; elementIdx < measInfoToBeSubscribedList->list.count; elementIdx++)
3077 measInfoSubscribedDb = NULLP;
3078 measToAddNode = NULLP;
3079 measItem = measInfoToBeSubscribedList->list.array[elementIdx];
3081 CM_LLIST_FIRST_NODE(measInfoSupportedList, supportedMeasNode);
3082 while(supportedMeasNode)
3084 measInfoSupportedDb = (MeasurementInfoForAction*)supportedMeasNode->node;
3085 switch(measItem->measType.present)
3087 case MeasurementType_PR_measName:
3089 if(!strcmp(measInfoSupportedDb->measurementTypeName, (char *)measItem->measType.choice.measName.buf))
3091 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
3096 case MeasurementType_PR_measID:
3098 if(measInfoSupportedDb->measurementTypeId == measItem->measType.choice.measID)
3100 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
3107 DU_LOG("\nERROR -> DUAPP: Invalid Measurement-type identifier in \
3108 E2SM-KPM Action Definition Format");
3111 } /* End of switch, for measurement type identifier */
3113 /* If measurement type is supported, add to measurement-subscription list */
3114 if(measInfoSubscribedDb)
3116 measInfoSubscribedDb->measurementTypeId = measInfoSupportedDb->measurementTypeId;
3117 memcpy(measInfoSubscribedDb->measurementTypeName, measInfoSupportedDb->measurementTypeName, \
3118 strlen(measInfoSupportedDb->measurementTypeName));
3120 DU_ALLOC(measToAddNode, sizeof(CmLList));
3123 measToAddNode->node = (PTR) measInfoSubscribedDb;
3124 cmLListAdd2Tail(measInfoSubscribedList, measToAddNode);
3126 /* Break out of while loop if measurement info is found in measurement-supported list */
3131 DU_FREE(measInfoSubscribedDb, sizeof(MeasurementInfo));
3132 measInfoSubscribedDb = NULLP;
3138 supportedMeasNode = supportedMeasNode->next;
3140 } /* End of while for traversing measurement-supported list in a report style */
3142 /* If a measurement-to-be-subscribed is not found in measurement-supported list in this report style
3144 * Delete all entries from measurement-subscription list and
3145 * Break out of for loop to search in next report style */
3146 if(!measInfoSubscribedDb)
3148 deleteMeasurementInfoList(measInfoSubscribedList);
3152 } /* End of for loop , traversing measurement-to-be-subscribed list */
3154 /* If all measurement-to-be-subscribed was found in measurement-supported list and
3155 * was added to measurement-subscription list successfully, return from here */
3156 if(measInfoToBeSubscribedList->list.count == measInfoSubscribedList->count)
3162 /*******************************************************************
3164 * @brief Extract E2SM-KPM Action definition
3168 * Function : extractRicActionDef
3170 * Functionality : This function :
3171 * - Decodes E2SM-KPM Action Definition
3172 * - Validates that action is supported by E2 node
3173 * - Stores action details in local DB
3175 * @params[in] RAN Function Database structure
3176 * RIC subscription's Action definition to be added to
3178 * RIC Action Definition buffer received from RIC
3179 * @return ROK - success
3182 ******************************************************************/
3183 uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefDb, RICactionDefinition_t *ricActionDef,\
3184 E2FailureCause *failureCause)
3186 bool memFailure = false;
3187 uint8_t styleIdx = 0;
3188 asn_dec_rval_t rval ={0};
3190 E2SM_KPM_ActionDefinition_t actionDef, *actionDefPtr = NULLP;
3191 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
3192 CmLListCp *measInfoSupportedList = NULLP;
3193 CmLListCp *measInfoSubscribedList = NULLP;
3195 /* Decoding E2SM-KPM Action Definition */
3196 actionDefPtr = &actionDef;
3197 memset(actionDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
3199 rval = aper_decode(0, &asn_DEF_E2SM_KPM_ActionDefinition, (void **)&actionDefPtr, ricActionDef->buf,\
3200 ricActionDef->size, 0, 0);
3201 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
3203 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Action Definition");
3204 failureCause->causeType = E2_PROTOCOL;
3205 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
3209 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDefPtr);
3212 /* Validate if Report style to subscribe is supported by E2 Node */
3213 for(styleIdx= 0; styleIdx < ranFuncDb->numOfReportStyleSupported; styleIdx++)
3215 /* Validate Report style type and report style format type is supported by E2 Node */
3216 if((ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType == actionDefPtr->ric_Style_Type) &&
3217 (ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType == actionDefPtr->actionDefinition_formats.present))
3219 /* Fetch Report stype type and format type */
3220 actionDefDb->styleType = actionDefPtr->ric_Style_Type;
3221 actionDefDb->formatType = actionDefPtr->actionDefinition_formats.present;
3223 switch(actionDefPtr->actionDefinition_formats.present)
3225 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
3227 actionFormat1 = actionDefPtr->actionDefinition_formats.choice.actionDefinition_Format1;
3229 /* Fetch granularity period */
3230 actionDefDb->choice.format1.granularityPeriod = actionFormat1->granulPeriod;
3232 /* Validate and add the Measurement to subscription list */
3233 measInfoSupportedList = &ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
3234 measInfoSubscribedList = &actionDefDb->choice.format1.measurementInfoList;
3235 if(extractMeasInfoList(measInfoSupportedList, &actionFormat1->measInfoList, \
3236 measInfoSubscribedList, &memFailure) == ROK)
3240 /* Free E2SM_KPM_ActionDefinition_t */
3241 freeAperDecodingOfRicActionDefinition(actionDefPtr);
3246 break; /* End of E2SM-KPM Action definition format 1 case */
3251 DU_LOG("\nERROR -> DUAPP: Only E2SM-KPM Action Definition Format 1 is supported");
3254 } /* End of switch for E2SM-KPM Action definition formats */
3259 failureCause->causeType = E2_MISCELLANEOUS;
3260 failureCause->cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3263 } /* End of for loop, traversing Report-styles-supported list in E2 node */
3265 /* Memset action Db and Free E2SM_KPM_ActionDefinition_t */
3266 memset(actionDefDb, 0, sizeof(ActionDefinition));
3267 freeAperDecodingOfRicActionDefinition(actionDefPtr);
3269 if(failureCause->causeType == E2_NOTHING)
3271 failureCause->causeType = E2_RIC_REQUEST;
3272 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3277 /*******************************************************************
3279 * @brief add RIC Subs action info
3283 * Function : addRicSubsAction
3285 * Functionality: add Ric Subs action info
3289 * Pointer to Ric Subc info
3290 * Action Sequence list
3293 * @return ROK - success
3296 ******************************************************************/
3298 CmLList *addRicSubsAction(RanFunction *ranFuncDb, PTR ricSubsInfo, CmLListCp *actionSequence, uint8_t procedureCode, E2FailureCause *failureCause)
3300 CmLList *actionNode = NULLP;
3301 ActionInfo *actionDb = NULLP;
3302 RICactionID_t ricActionID;
3303 RICactionType_t ricActionType;
3304 RICactionDefinition_t *ricActionDefinition= NULLP;
3305 RICaction_ToBeSetup_Item_t *setupItem= NULLP;
3306 RICaction_ToBeAddedForModification_Item_t *addIem= NULLP;
3307 RICaction_ToBeModifiedForModification_Item_t *modifiedItem= NULLP;
3309 switch(procedureCode)
3311 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
3313 setupItem = (RICaction_ToBeSetup_Item_t *)ricSubsInfo;
3314 ricActionID= setupItem->ricActionID;
3315 ricActionType= setupItem->ricActionType;
3316 if(setupItem->ricActionDefinition)
3318 ricActionDefinition = setupItem->ricActionDefinition;
3322 case ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item:
3324 addIem = (RICaction_ToBeAddedForModification_Item_t*) ricSubsInfo;
3325 ricActionID= addIem->ricActionID;
3326 ricActionType= addIem->ricActionType;
3327 ricActionDefinition = &addIem->ricActionDefinition;
3331 case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item:
3333 modifiedItem= (RICaction_ToBeModifiedForModification_Item_t*)ricSubsInfo;
3334 ricActionID= modifiedItem->ricActionID;
3335 /* Added since ricActionType IE is not present in case of
3337 ricActionType = RICactionType_report;
3338 if(modifiedItem->ricActionDefinition)
3340 ricActionDefinition = modifiedItem->ricActionDefinition;
3347 DU_ALLOC(actionDb, sizeof(ActionInfo));
3350 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
3353 if(ricActionType== RICactionType_report)
3355 actionDb->actionId = ricActionID;
3356 actionDb->type = REPORT;
3358 if(extractRicActionDef(ranFuncDb, &actionDb->definition, ricActionDefinition, failureCause) == ROK)
3360 actionDb->action = CONFIG_ADD;
3363 DU_ALLOC(actionNode, sizeof(CmLList));
3366 actionNode->node = (PTR) actionDb;
3367 cmLListAdd2Tail(actionSequence, actionNode);
3371 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
3372 DU_FREE(actionDb, sizeof(ActionInfo));
3379 /*******************************************************************
3381 * @brief Extract RIC Action to be setup
3385 * Function : extractRicActionToBeSetup
3387 * Functionality : This function :
3388 * - Validates that each action-to-be-setup is supported by E2 node
3389 * - Stores event trigger details in local DB
3391 * @params[in] RAN Function Database structure
3392 * RIC Subscription Info to be added to RAN function
3393 * RIC Action To Be Setup List received from RIC
3394 * @return ROK - success
3397 ******************************************************************/
3398 uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
3399 RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause, PendingSubsRspInfo *subsRsp)
3401 CmLList *actionNode = NULLP;
3402 uint8_t actionIdx = 0;
3403 uint8_t ricActionId = 0;
3404 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
3406 if(actionList->list.array)
3408 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
3410 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)actionList->list.array[actionIdx];
3411 switch(actionItem->id)
3413 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
3415 /* If Action type is REPORT and
3416 * If RIC action definition's extraction and validation passes,
3418 * This action is added to action sequence list of subscription info */
3419 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeSetup_Item,\
3420 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item, failureCause);
3424 /* In case of any failure, action is rejected
3425 * Added to rejected-action-list in subscription response */
3426 subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId;
3427 if(failureCause->causeType == E2_NOTHING)
3429 failureCause->causeType = E2_RIC_REQUEST;
3430 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
3432 memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \
3433 failureCause, sizeof(E2FailureCause));
3434 subsRsp->numOfRejectedActions++;
3439 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
3445 /* If there is even 1 action that can be added, return ROK */
3446 if(ricSubscriptionInfo->actionSequence.count)
3449 if(failureCause->causeType == E2_NOTHING)
3451 failureCause->causeType = E2_RIC_REQUEST;
3452 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3457 /******************************************************************
3459 * @brief Processes RIC Subscription Req sent by RIC
3463 * Function : procRicSubscriptionRequest
3465 * Functionality: Processes RIC Subscription Request from RIC
3467 * @params[in] E2AP_PDU_t ASN decoded E2AP message
3468 * @return ROK - success
3471 * ****************************************************************/
3472 uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg)
3476 uint16_t ranFuncId = 0;
3477 RicRequestId ricReqId;
3478 CmLList *ricSubscriptionNode = NULLP;
3479 RanFunction *ranFuncDb = NULLP;
3480 RICsubscriptionRequest_t *ricSubsReq = NULLP;
3481 RICsubscriptionDetails_t *subsDetails = NULLP;
3482 RicSubscription *ricSubscriptionInfo = NULLP;
3483 E2FailureCause failureCause;
3485 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
3487 memset(&failureCause, 0, sizeof(E2FailureCause));
3488 memset(&ricReqId, 0, sizeof(RicRequestId));
3490 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
3491 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
3493 if(ricSubsReq->protocolIEs.list.array[idx])
3495 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
3497 case ProtocolIE_IDE2_id_RICrequestID:
3499 ricReqId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID;
3500 ricReqId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID;
3505 case ProtocolIE_IDE2_id_RANfunctionID:
3507 ranFuncId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID;
3509 /* Validating RAN Function id */
3510 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
3514 failureCause.causeType = E2_RIC_REQUEST;
3515 failureCause.cause = E2_RAN_FUNCTION_ID_INVALID;
3520 if(ranFuncDb->numPendingSubsRsp >= MAX_PENDING_SUBSCRIPTION_RSP)
3522 failureCause.causeType = E2_RIC_REQUEST;
3523 failureCause.cause = E2_FUNCTION_RESOURCE_LIMIT;
3528 DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription));
3529 if(!ricSubscriptionInfo)
3531 DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
3532 failureCause.causeType = E2_MISCELLANEOUS;
3533 failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3537 ricSubscriptionInfo->requestId.requestorId = ricReqId.requestorId;
3538 ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId;
3539 ricSubscriptionInfo->ranFuncId = ranFuncId;
3541 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3542 memcpy(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].requestId,
3543 &ricReqId, sizeof(RicRequestId));
3544 ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].ranFuncId = ranFuncId;
3548 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
3550 subsDetails = &ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails;
3552 /* Decode, Validate and record Event Trigger Definition */
3553 if(extractEventTriggerDef(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricEventTriggerDefinition, \
3554 &failureCause) != ROK)
3560 /* Decode, Validate and record RIC actions */
3561 if(extractRicActionToBeSetup(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricAction_ToBeSetup_List, \
3562 &failureCause, &ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp]) != ROK)
3571 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
3572 ricSubsReq->protocolIEs.list.array[idx]->id);
3581 freeAperDecodingOfRicSubsReq(ricSubsReq);
3585 cmInitTimers(&(ricSubscriptionInfo->ricSubsReportTimer), 1);
3586 ricSubscriptionInfo->action = CONFIG_ADD;
3588 /* Add RAN subcription detail to RAN function */
3589 DU_ALLOC(ricSubscriptionNode, sizeof(CmLList));
3590 if(ricSubscriptionNode)
3592 ricSubscriptionNode->node = (PTR) ricSubscriptionInfo;
3593 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubscriptionNode);
3596 ranFuncDb->numPendingSubsRsp++;
3598 /* Send statistics request to other DU entities */
3599 BuildAndSendStatsReq(ricSubscriptionInfo);
3603 DU_FREE(ricSubscriptionInfo, sizeof(RicSubscription));
3607 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3610 /* Send RIC Subcription Failure */
3611 BuildAndSendRicSubscriptionFailure(ricReqId, ranFuncId, failureCause);
3616 /******************************************************************
3618 * @brief Free RIC Subscription Failure
3622 * Function : FreeRicSubscriptionFailure
3624 * Functionality: Free RIC Subscription Failure
3626 * @params[in] E2AP PDU
3629 * ****************************************************************/
3630 void FreeRicSubscriptionFailure(E2AP_PDU_t *e2apMsg)
3632 uint8_t elemIdx = 0;
3633 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3637 if(e2apMsg->choice.unsuccessfulOutcome)
3639 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3640 if(ricSubscriptionFailure->protocolIEs.list.array)
3642 for(elemIdx = 0; elemIdx < ricSubscriptionFailure->protocolIEs.list.count; elemIdx++)
3644 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3646 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3648 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3650 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3654 /******************************************************************
3656 * @brief Fill and Send RIC Subscription Failure to RIC
3660 * Function : BuildAndSendRicSubscriptionFailure
3662 * Functionality: Fill and Send RIC Subscription Failure to RIC
3664 * @params[in] RIC Request ID
3667 * @return ROK - success
3670 * ****************************************************************/
3671 uint8_t BuildAndSendRicSubscriptionFailure(RicRequestId ricReqId, uint16_t ranFuncId, E2FailureCause failureCause)
3673 uint8_t ret = RFAILED;
3674 uint8_t elementCnt = 0, elemIdx = 0;
3675 E2AP_PDU_t *e2apMsg = NULLP;
3676 asn_enc_rval_t encRetVal; /* Encoder return value */
3677 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3678 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3682 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Failure\n");
3684 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3685 if(e2apMsg == NULLP)
3687 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3691 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3692 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3693 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3695 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3698 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
3699 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3700 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure;
3702 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3705 ricSubscriptionFailure->protocolIEs.list.count = elementCnt;
3706 ricSubscriptionFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionFailure_IEs_t *);
3707 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3708 if(!ricSubscriptionFailure->protocolIEs.list.array)
3710 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3714 for(elemIdx = 0; elemIdx < elementCnt; elemIdx++)
3716 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3717 if(!ricSubscriptionFailure->protocolIEs.list.array[elemIdx])
3719 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d] for IE at index [%d]", \
3720 __func__, __LINE__, elemIdx);
3724 if(elemIdx < elementCnt)
3729 /* RIC Request ID */
3730 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3731 ricSubsFailIe->id = ProtocolIE_IDE2_id_RICrequestID;
3732 ricSubsFailIe->criticality = CriticalityE2_reject;
3733 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
3734 ricSubsFailIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3735 ricSubsFailIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3737 /* RAN Function ID */
3738 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3739 ricSubsFailIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3740 ricSubsFailIe->criticality = CriticalityE2_reject;
3741 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
3742 ricSubsFailIe->value.choice.RANfunctionID = ranFuncId;
3745 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3746 ricSubsFailIe->id = ProtocolIE_IDE2_id_CauseE2;
3747 ricSubsFailIe->criticality = CriticalityE2_reject;
3748 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_CauseE2;
3749 fillE2Cause(&ricSubsFailIe->value.choice.CauseE2, failureCause);
3751 /* Prints the Msg formed */
3752 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3753 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3755 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3756 if(encRetVal.encoded == ENCODE_FAIL)
3758 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Failure Message (at %s)\n",\
3759 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3764 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Failure Message \n");
3765 #ifdef DEBUG_ASN_PRINT
3766 for(int i=0; i< encBufSize; i++)
3768 printf("%x",encBuf[i]);
3773 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
3775 DU_LOG("\nINFO --> E2AP : Sending RIC Subscription Failure");
3781 FreeRicSubscriptionFailure(e2apMsg);
3785 /*******************************************************************
3787 * @brief Free the RicIndication Message
3791 * Function : FreeRicIndication
3793 * Functionality: Free the RicIndication Message
3798 ******************************************************************/
3799 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
3802 RICindication_t *ricIndicationMsg= NULLP;
3804 if(e2apMsg != NULLP)
3806 if(e2apMsg->choice.initiatingMessage != NULLP)
3808 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
3809 if(ricIndicationMsg!= NULLP)
3811 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
3813 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
3815 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
3817 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
3819 case ProtocolIE_IDE2_id_RICrequestID:
3820 case ProtocolIE_IDE2_id_RANfunctionID:
3821 case ProtocolIE_IDE2_id_RICactionID:
3822 case ProtocolIE_IDE2_id_RICindicationType:
3825 case ProtocolIE_IDE2_id_RICindicationHeader:
3827 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
3828 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
3831 case ProtocolIE_IDE2_id_RICindicationMessage:
3833 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
3834 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
3840 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
3843 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
3846 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3848 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3852 /*******************************************************************
3854 * @brief Free measurement record
3858 * Function : freeMeasRecord
3860 * Functionality: Free all measurement recorded for a measurement
3861 * within an action in a RIC subscription
3863 * @param Measurement data to be freed
3866 ******************************************************************/
3867 void freeMeasData(MeasurementData_t *measData)
3869 uint8_t measIdx = 0, measRecIdx = 0;
3870 MeasurementRecord_t *measRecord = NULLP;
3872 if(measData->list.array)
3874 for(measIdx = 0; measIdx < measData->list.count; measIdx++)
3876 if(measData->list.array[measIdx])
3878 measRecord = &measData->list.array[measIdx]->measRecord;
3879 if(measRecord->list.array)
3881 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3883 DU_FREE(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3885 DU_FREE(measRecord->list.array, measRecord->list.size);
3887 DU_FREE(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
3890 DU_FREE(measData->list.array, measData->list.size);
3894 /*******************************************************************
3896 * @brief Fill measurement info list
3900 * Function : freeMeasInfoList
3902 * Functionality: Fills all measurement info within an action
3903 * in a RIC subscription
3905 * @param Measurement Info list to be freed
3908 ******************************************************************/
3909 void freeMeasInfoList(MeasurementInfoList_t *measInfoList)
3911 uint8_t measInfoIdx = 0;
3913 if(measInfoList->list.array)
3915 for(measInfoIdx = 0; measInfoIdx < measInfoList->list.count; measInfoIdx++)
3917 if(measInfoList->list.array[measInfoIdx])
3919 DU_FREE(measInfoList->list.array[measInfoIdx]->measType.choice.measName.buf, \
3920 measInfoList->list.array[measInfoIdx]->measType.choice.measName.size);
3922 DU_FREE(measInfoList->list.array[measInfoIdx], measInfoList->list.size);
3925 DU_FREE(measInfoList->list.array, measInfoList->list.size);
3929 /*******************************************************************
3931 * @brief Free E2SM-KPM Indication Message
3935 * Function : FreeE2smKpmIndicationMessage
3937 * Functionality: Free E2SM-KPM Indication Message
3939 * @param E2SM-KPM Indication message to be freed
3942 ******************************************************************/
3943 void FreeE2smKpmIndicationMessage(E2SM_KPM_IndicationMessage_t *e2smKpmIndMsg)
3945 E2SM_KPM_IndicationMessage_Format1_t *format1Msg = NULLP;
3947 switch(e2smKpmIndMsg->indicationMessage_formats.present)
3949 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
3951 if(e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1)
3953 format1Msg = e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1;
3955 /* Measurement Data */
3956 freeMeasData(&format1Msg->measData);
3958 /* Measurement Info List */
3959 if(format1Msg->measInfoList)
3961 freeMeasInfoList(format1Msg->measInfoList);
3962 DU_FREE(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
3965 /* Granularity Period */
3966 DU_FREE(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
3968 DU_FREE(format1Msg, sizeof(E2SM_KPM_IndicationMessage_Format1_t));
3973 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
3974 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
3980 /*******************************************************************
3982 * @brief Fill measurement record
3986 * Function : fillMeasRecord
3988 * Functionality: Fills all measurement value for a measurement
3989 * within an action in a RIC subscription
3991 * @param Measurement record to be filled
3992 * Measurement database with measurement records
3993 * @return ROK - success
3996 ******************************************************************/
3997 uint8_t fillMeasRecord(MeasurementRecord_t *measRecord, MeasurementInfo *measInfoDb)
3999 uint8_t measRecIdx = 0;
4000 CmLList *measValNode = NULLP;
4003 measRecord->list.count = measInfoDb->measuredValue.count;
4004 measRecord->list.size = measRecord->list.count * sizeof(MeasurementRecordItem_t *);
4006 DU_ALLOC(measRecord->list.array, measRecord->list.size);
4007 if(!measRecord->list.array)
4009 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4013 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
4015 DU_ALLOC(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
4016 if(!measRecord->list.array[measRecIdx])
4018 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4024 CM_LLIST_FIRST_NODE(&measInfoDb->measuredValue, measValNode);
4027 measVal = *(double *)measValNode->node;
4028 if(measVal == (int)measVal)
4030 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_integer;
4031 measRecord->list.array[measRecIdx]->choice.integer = (int)measVal;
4035 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_real;
4036 measRecord->list.array[measRecIdx]->choice.real = measVal;
4039 measValNode= measValNode->next;
4040 /* Once the measurement record is added to the message, delete it from DB */
4043 deleteMeasuredValueList(&measInfoDb->measuredValue);
4047 /*******************************************************************
4049 * @brief Fills measuerement data
4053 * Function : fillMeasData
4055 * Functionality: Fill all measurement recorded for all measurements
4056 * in an action in a RIC subscription
4058 * @param Measurement data to be filled
4059 * Measurement info list from an action DB
4060 * @return ROK - success
4063 ******************************************************************/
4064 uint8_t fillMeasData(MeasurementData_t *measData, CmLListCp *measInfoListDb)
4066 uint8_t measIdx = 0;
4067 CmLList *measInfoNode = NULLP;
4068 MeasurementInfo *measInfoDb = NULLP;
4069 MeasurementRecord_t *measRecord = NULLP;
4071 measData->list.count = measInfoListDb->count;
4072 measData->list.size = measData->list.count * sizeof(MeasurementDataItem_t *);
4074 DU_ALLOC(measData->list.array, measData->list.size);
4075 if(!measData->list.array)
4077 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4082 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4085 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4088 DU_ALLOC(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
4089 if(!measData->list.array[measIdx])
4091 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4095 measRecord = &measData->list.array[measIdx]->measRecord;
4096 if(fillMeasRecord(measRecord, measInfoDb) != ROK)
4098 DU_LOG("\nERROR --> E2AP : Failed to fill measurement record");
4103 measInfoNode = measInfoNode->next;
4109 /*******************************************************************
4111 * @brief Fill all measurement info
4115 * Function : fillMeasInfoList
4117 * Functionality: Fills all measurement info belonging to an action
4118 * in a RIC subscription
4120 * @param Measurement Info list to be filled
4121 * Measurement Info list from E2AP DB
4122 * @return ROK - success
4125 ******************************************************************/
4126 uint8_t fillMeasInfoList(MeasurementInfoList_t *measInfoList, CmLListCp *measInfoListDb)
4128 uint8_t measInfoIdx = 0;
4129 CmLList *measInfoNode = NULLP;
4130 MeasurementInfo *measInfoDb = NULLP;
4131 MeasurementInfoItem_t *measInfoItem = NULLP;
4133 measInfoList->list.count = measInfoListDb->count;
4134 measInfoList->list.size = measInfoList->list.count * sizeof(MeasurementInfoItem_t *);
4136 DU_ALLOC(measInfoList->list.array, measInfoList->list.size);
4137 if(!measInfoList->list.array)
4139 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4144 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4147 DU_ALLOC(measInfoList->list.array[measInfoIdx], sizeof(MeasurementInfoItem_t));
4148 if(!measInfoList->list.array[measInfoIdx])
4150 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4154 measInfoItem = measInfoList->list.array[measInfoIdx];
4155 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4158 /* Measurement Type */
4159 measInfoItem->measType.present = MeasurementType_PR_measName;
4160 measInfoItem->measType.choice.measName.size = strlen(measInfoDb->measurementTypeName);
4162 DU_ALLOC(measInfoItem->measType.choice.measName.buf, measInfoItem->measType.choice.measName.size);
4163 if(!measInfoItem->measType.choice.measName.buf)
4165 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4169 memcpy(measInfoItem->measType.choice.measName.buf, measInfoDb->measurementTypeName,\
4170 measInfoItem->measType.choice.measName.size);
4174 measInfoNode = measInfoNode->next;
4181 /*******************************************************************
4183 * @brief Fill E2SM-KPM Indication Message Format 1
4187 * Function : fillE2smKpmIndMsgFormat1
4189 * Functionality: Fill E2SM-KPM Indication Message Format 1
4191 * @param Format 1 Message to be filled
4192 * Action Definition format 1 from E2AP DB
4193 * @return ROK - success
4196 ******************************************************************/
4197 uint8_t fillE2smKpmIndMsgFormat1(E2SM_KPM_IndicationMessage_Format1_t *format1Msg, ActionDefFormat1 *format1)
4199 /* Measurement Data */
4200 if(fillMeasData(&format1Msg->measData, &format1->measurementInfoList) != ROK)
4202 DU_LOG("\nERROR --> E2AP : Failed to fill measurement data");
4206 /* Measurement Information */
4207 DU_ALLOC(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
4208 if(!format1Msg->measInfoList)
4210 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4214 if(fillMeasInfoList(format1Msg->measInfoList, &format1->measurementInfoList) != ROK)
4216 DU_LOG("\nERROR --> E2AP : Failed to fill measurement information list");
4220 /* Granularity Period */
4221 DU_ALLOC(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
4222 if(!format1Msg->granulPeriod)
4224 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4227 *(format1Msg->granulPeriod) = format1->granularityPeriod;
4232 /*******************************************************************
4234 * @brief Fill RIC Indication Message buffer
4238 * Function : fillRicIndMsgBuf
4240 * Functionality: Fill E2SM-KPM Indication Message
4241 * Encode this message and copy to RIC Indication Message buffer
4243 * @param RIC Indication Message buffer to be filled
4244 * Source action info from E2AP DB
4245 * @return ROK - success
4248 ******************************************************************/
4249 uint8_t fillRicIndMsgBuf(RICindicationMessage_t *ricIndMsgBuf, ActionInfo *actionInfo)
4251 uint8_t ret = RFAILED;
4252 bool failedInFormat = false;
4253 E2SM_KPM_IndicationMessage_t e2smKpmIndMsg;
4254 asn_enc_rval_t encRetVal; /* Encoder return value */
4256 memset(&e2smKpmIndMsg, 0, sizeof(E2SM_KPM_IndicationMessage_t));
4260 /* E2SM-KPM Indication message format type */
4261 e2smKpmIndMsg.indicationMessage_formats.present = actionInfo->definition.formatType;
4262 switch(e2smKpmIndMsg.indicationMessage_formats.present)
4264 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
4266 /* E2SM-KPM Indication message format 1 */
4267 DU_ALLOC(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4268 sizeof(E2SM_KPM_IndicationMessage_Format1_t));
4269 if(!e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1)
4271 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4272 failedInFormat = true;
4276 if(fillE2smKpmIndMsgFormat1(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4277 &actionInfo->definition.choice.format1) != ROK)
4279 DU_LOG("\nERROR --> E2AP : Failed to fill E2SM-KPM Indication message format 1");
4280 failedInFormat = true;
4286 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
4287 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
4290 DU_LOG("\nERROR --> E2AP : fillRicIndMsgBuf: Only Format 1 supported");
4291 failedInFormat = true;
4299 /* Encode E2SM-KPM Indication Message */
4300 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationMessage, &e2smKpmIndMsg);
4301 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4303 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationMessage, 0, &e2smKpmIndMsg, PrepFinalEncBuf, encBuf);
4304 if(encRetVal.encoded == ENCODE_FAIL)
4306 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Message (at %s)\n",\
4307 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4312 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Message \n");
4313 #ifdef DEBUG_ASN_PRINT
4314 for(int i=0; i< encBufSize; i++)
4316 printf("%x",encBuf[i]);
4321 /* Copy encoded string to RIC Indication Message buffer */
4322 ricIndMsgBuf->size = encBufSize;
4323 DU_ALLOC(ricIndMsgBuf->buf, ricIndMsgBuf->size);
4324 if(!ricIndMsgBuf->buf)
4326 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4329 memset(ricIndMsgBuf->buf, 0, ricIndMsgBuf->size);
4330 memcpy(ricIndMsgBuf->buf, encBuf, encBufSize);
4336 /* Free E2SM-KPM Indication Message */
4337 FreeE2smKpmIndicationMessage(&e2smKpmIndMsg);
4342 /*******************************************************************
4344 * @brief Free E2SM-KPM Indication Header
4348 * Function : FreeE2smKpmIndicationHeader
4350 * Functionality: Free E2SM-KPM Indication Header
4352 * @param E2SM-KPM Indication Header to be free
4355 ******************************************************************/
4356 void FreeE2smKpmIndicationHeader(E2SM_KPM_IndicationHeader_t *e2smKpmIndHdr)
4358 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4362 switch(e2smKpmIndHdr->indicationHeader_formats.present)
4364 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4366 if(e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1)
4368 format1 = e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1;
4370 DU_FREE(format1->colletStartTime.buf, format1->colletStartTime.size);
4371 DU_FREE(format1, sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4375 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4382 /*******************************************************************
4384 * @brief Fill RIC Indication Header buffer
4388 * Function : fillRicIndHeader
4390 * Functionality: Fill E2SM-KPM Indication Header
4391 * Encode this message and copy to RIC Indication Header buffer
4393 * @param RIC Indication Header buffer to be filled
4394 * Source RIC subscription info from E2AP DB
4395 * @return ROK - success
4398 ******************************************************************/
4399 uint8_t fillRicIndHeader(RICindicationHeader_t *ricIndHdr, RicSubscription *ricSubsInfo)
4401 uint8_t ret = RFAILED;
4402 uint8_t secBufIdx = 0, milliSecBufIdx = 0;
4404 bool formatFailure = false;
4405 RanFunction *ranFunc = NULLP;
4406 ReportStartTime *startTime = NULLP;
4407 E2SM_KPM_IndicationHeader_t e2smKpmIndHdr;
4408 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4409 asn_enc_rval_t encRetVal; /* Encoder return value */
4413 ranFunc = fetchRanFuncFromRanFuncId(ricSubsInfo->ranFuncId);
4414 if(ranFunc == NULLP)
4416 DU_LOG("\nERROR --> E2AP : RAN Function ID [%d] not found", ricSubsInfo->ranFuncId);
4420 memset(&e2smKpmIndHdr, 0, sizeof(E2SM_KPM_IndicationHeader_t));
4422 e2smKpmIndHdr.indicationHeader_formats.present = ranFunc->ricIndicationHeaderFormat;
4423 switch(e2smKpmIndHdr.indicationHeader_formats.present)
4425 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4427 DU_ALLOC(e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1, \
4428 sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4429 if(!e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1)
4431 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4432 formatFailure = true;
4435 format1 = e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1;
4437 /* Fetch reporting period start time from DB */
4438 switch(ricSubsInfo->eventTriggerDefinition.formatType)
4442 startTime = &ricSubsInfo->eventTriggerDefinition.choice.format1.startTime;
4446 format1->colletStartTime.size = 8 * sizeof(uint8_t);
4447 DU_ALLOC(format1->colletStartTime.buf, format1->colletStartTime.size);
4448 if(!format1->colletStartTime.buf)
4450 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4451 formatFailure = true;
4455 /* As per O-RAN.WG3.E2SM-KPM-R003-v03.00, section 8.3.12 and
4456 * RFC 5905, section 6 :
4457 * Time stamp has a 64-bit format where first 32-bit is seconds
4458 * and next 32-bit is fraction in picosecond-level.
4459 * This fraction has been rounded in microseconds.
4462 * Storing 32-bit seconds at MSB 0-3 and
4463 * 32-bit milliseconds at next 4 bytes i.e. bytes 4-7
4467 for(byteIdx = 3; byteIdx >= 0; byteIdx--)
4469 format1->colletStartTime.buf[secBufIdx++] = startTime->timeInSec >> (8*byteIdx);
4470 format1->colletStartTime.buf[milliSecBufIdx++] = startTime->timeInMilliSec >> (8*byteIdx);
4475 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4478 DU_LOG("\nERROR --> E2AP : Only E2SM-KPM Indication Header Format 1 supported");
4479 formatFailure = true;
4487 /* Encode E2SM-KPM Indication Header */
4488 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationHeader, &e2smKpmIndHdr);
4489 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4491 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationHeader, 0, &e2smKpmIndHdr, PrepFinalEncBuf, encBuf);
4492 if(encRetVal.encoded == ENCODE_FAIL)
4494 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Header (at %s)\n",\
4495 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4500 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Header \n");
4501 #ifdef DEBUG_ASN_PRINT
4502 for(int i=0; i< encBufSize; i++)
4504 printf("%x",encBuf[i]);
4509 /* Copy encoded string to RIC Indication Header buffer */
4510 ricIndHdr->size = encBufSize;
4511 DU_ALLOC(ricIndHdr->buf, ricIndHdr->size);
4514 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4517 memset(ricIndHdr->buf, 0, ricIndHdr->size);
4518 memcpy(ricIndHdr->buf, encBuf, encBufSize);
4523 /* Free E2SM-KPM Indication Header */
4524 FreeE2smKpmIndicationHeader(&e2smKpmIndHdr);
4529 /*******************************************************************
4531 * brief Fill the RIC Indication Message
4535 * Function : fillRicIndication
4537 * Functionality: Fills the RIC Indication Message
4539 * @param RIC Indication Message to be filled
4540 * RIC Subscription DB
4542 * @return ROK - success
4545 ******************************************************************/
4546 uint8_t fillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4548 uint8_t elementCnt = 0, idx = 0;
4553 ricIndicationMsg->protocolIEs.list.count = elementCnt;
4554 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_IEs_t *);
4556 /* Initialize the Ric Indication members */
4557 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, ricIndicationMsg->protocolIEs.list.size);
4558 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
4560 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4564 for(idx=0; idx<elementCnt; idx++)
4566 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx], sizeof(RICindication_IEs_t));
4567 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
4569 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4574 /* RIC Request ID */
4576 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
4577 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4578 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICrequestID;
4579 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = \
4580 ricSubscriptionInfo->requestId.requestorId;
4581 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = \
4582 ricSubscriptionInfo->requestId.instanceId;
4584 /* RAN Function ID */
4586 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
4587 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4588 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RANfunctionID;
4589 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ricSubscriptionInfo->ranFuncId;
4593 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
4594 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4595 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICactionID;
4596 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = actionInfo->actionId;
4598 /* RIC Indication Type */
4600 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
4601 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4602 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationType;
4603 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = actionInfo->type;
4605 /* RIC Indication Header */
4607 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
4608 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4609 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationHeader;
4610 if(fillRicIndHeader(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader, \
4611 ricSubscriptionInfo) != ROK)
4613 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication header");
4617 /* RIC Indication Message */
4619 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
4620 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4621 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationMessage;
4622 if(fillRicIndMsgBuf(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage, \
4625 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication Message");
4632 /*******************************************************************
4634 * @brief Builds and Send the RicIndication Message
4638 * Function : BuildAndSendRicIndication
4640 * Functionality:Fills the RicIndication Message
4642 * @return ROK - success
4645 ******************************************************************/
4647 uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4649 uint8_t ret = RFAILED;
4650 E2AP_PDU_t *e2apMsg = NULLP;
4651 RICindication_t *ricIndicationMsg = NULLP;
4652 asn_enc_rval_t encRetVal; /* Encoder return value */
4656 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
4658 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4659 if(e2apMsg == NULLP)
4661 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4665 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4666 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4667 if(e2apMsg->choice.initiatingMessage == NULLP)
4669 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4672 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
4673 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4674 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
4676 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
4678 if(fillRicIndication(ricIndicationMsg, ricSubscriptionInfo, actionInfo) != ROK)
4680 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication message");
4684 /* Prints the Msg formed */
4685 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4686 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4688 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4690 if(encRetVal.encoded == ENCODE_FAIL)
4692 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
4693 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4698 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
4699 #ifdef DEBUG_ASN_PRINT
4700 for(int i=0; i< encBufSize; i++)
4702 printf("%x",encBuf[i]);
4707 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
4709 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
4715 FreeRicIndication(e2apMsg);
4719 /*******************************************************************
4721 * @brief free e2 node component configuration req and rsp
4725 * Function : freeE2NodeComponentConfiguration
4728 * - free e2 node component configuration req and rsp
4730 * @params[in] E2nodeComponentConfiguration_t *e2nodeComponentConfiguration
4731 * @return ROK - success
4734 * ****************************************************************/
4736 void freeE2NodeComponentConfiguration(E2nodeComponentConfiguration_t *e2nodeComponentConfiguration)
4738 /* Free E2 Node Component Request Part */
4739 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentRequestPart.buf, e2nodeComponentConfiguration->e2nodeComponentRequestPart.size);
4741 /* Free E2 Node Component Response Part */
4742 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentResponsePart.buf, e2nodeComponentConfiguration->e2nodeComponentResponsePart.size);
4746 /*******************************************************************
4748 * @brief free e2 node component component identifier
4752 * Function : freeE2NodeComponentIdentifier
4755 * - free e2 node component component identifier
4757 * @params[in] E2nodeComponentID_t *componentID
4758 * @return ROK - success
4761 * ****************************************************************/
4763 void freeE2NodeComponentIdentifier(E2nodeComponentID_t *componentID)
4765 if(componentID->choice.e2nodeComponentInterfaceTypeF1)
4767 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
4768 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
4773 /*******************************************************************
4775 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
4779 * Function : FreeE2NodeConfigUpdate
4782 * - freeing the memory allocated for E2nodeConfigurationUpdate
4784 * @params[in] E2AP_PDU_t *e2apMsg
4785 * @return ROK - success
4788 * ****************************************************************/
4790 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
4792 uint8_t arrIdx =0, e2NodeUpdateListIdx=0, e2NodeRemovalListIdx=0, e2NodeAddListIdx=0;
4793 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate =NULL;
4794 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList =NULL;
4795 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItem =NULL;
4796 E2nodeComponentConfigRemoval_List_t *e2NodeRemovalList =NULL;
4797 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItem =NULL;
4798 E2nodeComponentConfigAddition_List_t *e2NodeAddList =NULL;
4799 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem =NULL;
4801 if(e2apMsg != NULLP)
4803 if(e2apMsg->choice.initiatingMessage != NULLP)
4805 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4806 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
4808 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
4810 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx])
4813 switch(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id)
4815 case ProtocolIE_IDE2_id_TransactionID:
4818 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
4820 e2NodeAddList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
4821 if(e2NodeAddList->list.array)
4823 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
4825 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
4827 freeE2NodeComponentConfiguration(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration);
4828 freeE2NodeComponentIdentifier(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID);
4829 DU_FREE(e2NodeAddItem, sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
4831 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
4835 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
4837 e2NodeUpdateList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List;
4838 if(e2NodeUpdateList->list.array)
4840 for(e2NodeUpdateListIdx = 0; e2NodeUpdateListIdx< e2NodeUpdateList->list.count; e2NodeUpdateListIdx++)
4842 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[e2NodeUpdateListIdx];
4844 freeE2NodeComponentConfiguration(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentConfiguration);
4845 freeE2NodeComponentIdentifier(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentID);
4846 DU_FREE(e2NodeUpdateItem, sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
4848 DU_FREE(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
4852 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
4854 e2NodeRemovalList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List;
4855 if(e2NodeRemovalList->list.array)
4857 for(e2NodeRemovalListIdx = 0; e2NodeRemovalListIdx< e2NodeRemovalList->list.count; e2NodeRemovalListIdx++)
4859 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemovalList->list.array[e2NodeRemovalListIdx];
4861 freeE2NodeComponentIdentifier(&e2NodeRemovalItem->value.choice.E2nodeComponentConfigRemoval_Item.e2nodeComponentID);
4862 DU_FREE(e2NodeRemovalItem, sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
4864 DU_FREE(e2NodeRemovalList->list.array, e2NodeRemovalList->list.size);
4872 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4875 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4877 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4879 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4883 /*******************************************************************
4885 * @brief Buld and send the E2 node config update msg
4889 * Function : BuildAndSendE2NodeConfigUpdate
4892 * - Buld and send the E2 node config update msg
4895 * @return ROK - success
4898 * ****************************************************************/
4900 uint8_t BuildAndSendE2NodeConfigUpdate(E2NodeConfigList *e2NodeList)
4902 uint8_t ret = RFAILED;
4903 uint8_t arrIdx = 0,elementCnt = 0;
4905 E2AP_PDU_t *e2apMsg = NULLP;
4906 asn_enc_rval_t encRetVal; /* Encoder return value */
4907 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
4909 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
4912 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4913 if(e2apMsg == NULLP)
4915 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4919 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4920 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4921 if(e2apMsg->choice.initiatingMessage == NULLP)
4923 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4926 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4927 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
4928 e2apMsg->choice.initiatingMessage->value.present = \
4929 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
4930 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4933 if(e2NodeList->addE2NodeCount)
4935 if(e2NodeList->updateE2NodeCount)
4937 if(e2NodeList->removeE2NodeCount)
4940 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
4941 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
4942 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4943 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
4945 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4949 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
4951 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4952 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
4955 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4960 if(arrIdx<elementCnt)
4964 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4965 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4966 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
4967 transId = assignTransactionId();
4968 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4970 if(e2NodeList->addE2NodeCount)
4973 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
4974 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4975 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigAddition_List;
4976 if(BuildE2NodeConfigAddList(&(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List),\
4977 ProcedureCodeE2_id_E2nodeConfigurationUpdate, e2NodeList->addE2NodeCount, e2NodeList->addE2Node)!=ROK)
4979 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
4984 if(e2NodeList->updateE2NodeCount)
4987 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate;
4988 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4989 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigUpdate_List;
4990 if(BuildE2NodeConfigUpdateList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List,\
4991 e2NodeList->updateE2NodeCount, e2NodeList->updateE2Node) != ROK)
4994 DU_LOG("\nERROR --> E2AP : Failed to update the E2 node configuration");
4999 if(e2NodeList->removeE2NodeCount)
5002 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval;
5003 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5004 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigRemoval_List;
5005 if(BuildE2NodeConfigRemoveList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List,\
5006 e2NodeList->removeE2NodeCount, e2NodeList->removeE2Node) != ROK)
5009 DU_LOG("\nERROR --> E2AP : Failed to remove the E2 node configuration");
5014 /* Prints the Msg formed */
5015 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5017 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5019 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5020 if(encRetVal.encoded == ENCODE_FAIL)
5022 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
5023 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5028 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
5029 #ifdef DEBUG_ASN_PRINT
5030 for(int i=0; i< encBufSize; i++)
5032 printf("%x",encBuf[i]);
5036 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
5038 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
5042 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5043 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5044 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.e2NodeConfigUpdate.configList, e2NodeList, sizeof(E2NodeConfigList));
5049 FreeE2NodeConfigUpdate(e2apMsg);
5053 /*******************************************************************
5055 * @brief Deallocate the memory allocated for E2ResetRequest msg
5059 * Function : FreeE2ResetRequest
5062 * - freeing the memory allocated for E2ResetRequest
5064 * @params[in] E2AP_PDU_t *e2apMsg
5065 * @return ROK - success
5068 * ****************************************************************/
5069 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
5072 ResetRequestE2_t *resetReq = NULLP;
5074 if(e2apMsg != NULLP)
5076 if(e2apMsg->choice.initiatingMessage != NULLP)
5078 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5079 if(resetReq->protocolIEs.list.array)
5081 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
5083 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5085 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5087 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5089 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5093 /*******************************************************************
5095 * @brief Build and send the E2 reset request msg
5099 * Function : BuildAndSendE2ResetRequest
5102 * - Buld and send the E2 reset request msg to RIC
5106 * @return ROK - success
5109 * ****************************************************************/
5110 uint8_t BuildAndSendE2ResetRequest(E2FailureCause resetCause)
5112 uint8_t ieIdx = 0, elementCnt = 0;
5113 uint16_t transId = 0;
5114 uint8_t ret = RFAILED;
5115 E2AP_PDU_t *e2apMsg = NULLP;
5116 ResetRequestE2_t *resetReq = NULLP;
5117 asn_enc_rval_t encRetVal; /* Encoder return value */
5119 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
5123 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5124 if(e2apMsg == NULLP)
5126 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
5130 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5131 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5132 if(e2apMsg->choice.initiatingMessage == NULLP)
5134 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
5138 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
5139 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5140 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
5141 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5144 resetReq->protocolIEs.list.count = elementCnt;
5145 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
5147 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5148 if(!resetReq->protocolIEs.list.array)
5150 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5151 Reset Request IE array");
5155 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5157 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5158 if(!resetReq->protocolIEs.list.array[ieIdx])
5160 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5161 Reset Request IE array element");
5166 /* In case of failure */
5167 if(ieIdx < elementCnt)
5171 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5172 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
5173 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
5174 transId = assignTransactionId();
5175 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
5178 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
5179 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
5180 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
5181 fillE2Cause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, resetCause);
5183 /* Prints the Msg formed */
5184 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5186 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5188 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
5190 if(encRetVal.encoded == ENCODE_FAIL)
5192 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
5193 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5198 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
5199 #ifdef DEBUG_ASN_PRINT
5200 for(int i=0; i< encBufSize; i++)
5202 printf("%x",encBuf[i]);
5206 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5208 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5212 /* In case the message is sent successfully, store the transaction info to
5213 * be used when response is received */
5214 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5215 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5221 /* Free all memory */
5222 FreeE2ResetRequest(e2apMsg);
5226 /*******************************************************************
5228 * @brief Deallocate the memory allocated for Reset Response msg
5232 * Function : freeAperDecodingOfE2ResetRsp
5235 * - freeing the memory allocated for Reset response
5237 * @params[in] ResetResponseE2_t *resetResponse
5240 * ****************************************************************/
5241 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
5247 if(resetResponse->protocolIEs.list.array)
5249 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5251 if(resetResponse->protocolIEs.list.array[ieIdx])
5253 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5255 case ProtocolIE_IDE2_id_TransactionID:
5258 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5261 free(resetResponse->protocolIEs.list.array[ieIdx]);
5264 free(resetResponse->protocolIEs.list.array);
5269 /******************************************************************
5271 * @brief Processes E2 Reset Response sent by RIC
5275 * Function : procResetResponse
5277 * Functionality: Processes E2 Reset Response sent by RIC
5279 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5282 * ****************************************************************/
5283 void procResetResponse(E2AP_PDU_t *e2apMsg)
5285 bool invalidTransId=false;
5287 uint16_t transId =0;
5288 uint16_t ranFuncIdx=0;
5289 ResetResponseE2_t *resetResponse =NULLP;
5291 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
5292 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
5294 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5296 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5298 case ProtocolIE_IDE2_id_TransactionID:
5300 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5301 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \
5302 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
5304 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5308 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5309 invalidTransId = true;
5313 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5315 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
5317 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
5319 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
5320 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
5327 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
5328 resetResponse->protocolIEs.list.array[ieIdx]->id);
5333 if(invalidTransId == true)
5339 freeAperDecodingOfE2ResetRsp(resetResponse);
5342 /******************************************************************
5344 * @brief Deallocation of memory allocated by aper decoder for e2 setup Failure
5348 * Function : freeAperDecodingOfE2SetupFailure
5350 * Functionality: Deallocation of memory allocated by aper decoder for e2
5353 * @params[in] E2setupFailure_t *e2SetupFailure;
5356 * ****************************************************************/
5357 void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure)
5363 if(e2SetupFailure->protocolIEs.list.array)
5365 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5367 if(e2SetupFailure->protocolIEs.list.array[arrIdx])
5369 free(e2SetupFailure->protocolIEs.list.array[arrIdx]);
5372 free(e2SetupFailure->protocolIEs.list.array);
5376 /******************************************************************
5378 * @brief Processes E2 Setup Failure sent by RIC
5382 * Function : procE2SetupFailure
5384 * Functionality: Processes E2 Setup failure sent by RIC
5386 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5387 * @return ROK - success
5390 * ****************************************************************/
5391 void procE2SetupFailure(E2AP_PDU_t *e2apMsg)
5393 uint16_t transId =0;
5394 uint8_t arrIdx =0, timerValue=0;
5395 E2setupFailure_t *e2SetupFailure;
5397 DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
5398 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
5400 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5402 switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id)
5404 case ProtocolIE_IDE2_id_TransactionID:
5406 transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5407 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
5408 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5410 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5414 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5419 case ProtocolIE_IDE2_id_TimeToWaitE2:
5421 timerValue = convertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
5422 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE)
5424 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue);
5428 DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
5436 freeAperDecodingOfE2SetupFailure(e2SetupFailure);
5438 /******************************************************************
5440 * @brief Deallocation of memory allocated by aper decoder for RIC service Query
5444 * Function : freeAperDecodingOfRicServiceQuery
5446 * Functionality: Deallocation of memory allocated by aper decoder for RIC
5449 * @params[in] RICserviceQuery_t *ricServiceQuery;
5452 * ****************************************************************/
5454 void freeAperDecodingOfRicServiceQuery(RICserviceQuery_t *ricServiceQuery)
5456 uint8_t arrIdx,ranFuncIdx;
5457 RANfunctionsID_List_t *ranFuncAddedList;
5461 if(ricServiceQuery->protocolIEs.list.array)
5463 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5465 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
5467 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5469 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5471 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5472 if(ranFuncAddedList->list.array)
5474 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5476 free(ranFuncAddedList->list.array[ranFuncIdx]);
5478 free(ranFuncAddedList->list.array);;
5485 free(ricServiceQuery->protocolIEs.list.array[arrIdx]);
5488 free(ricServiceQuery->protocolIEs.list.array);
5492 /*******************************************************************
5494 * @brief Build RanFunction Delete List
5498 * Function : BuildRanFunctionDeleteList
5500 * Functionality: Build RanFunction Delete List
5503 * RANfunctionsID List
5504 * Count of the RAN function
5505 * Received RAN function list
5507 * @return ROK - success
5510 ******************************************************************/
5512 uint8_t BuildRanFunctionDeleteList(RANfunctionsID_List_t *deleteList, uint8_t count, RanFuncInfo *recvdRanFunc)
5514 uint8_t ranFuncIdx=0;
5515 RANfunctionID_ItemIEs_t *delRanFuncItem;
5519 deleteList->list.count = count;
5520 deleteList->list.size = deleteList->list.count * sizeof(RANfunctionID_ItemIEs_t*);
5521 DU_ALLOC(deleteList->list.array, deleteList->list.size);
5522 if(deleteList->list.array == NULLP)
5524 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5527 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
5529 DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t));
5530 if(deleteList->list.array[ranFuncIdx] == NULLP)
5532 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5535 delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx];
5536 delRanFuncItem->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
5537 delRanFuncItem->criticality = CriticalityE2_ignore;
5538 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionID = recvdRanFunc[ranFuncIdx].id;
5539 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionRevision = recvdRanFunc[ranFuncIdx].revisionCounter;
5545 /*******************************************************************
5547 * @brief De Allocate Ric Service Update message
5551 * Function : FreeRicServiceUpdate
5553 * Functionality: De-Allocating Ric Service Update message
5555 * @params[in] E2AP_PDU_t *e2apMsg
5559 * ****************************************************************/
5561 void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg)
5564 uint8_t ranFuncAddListIdx=0, ranFuncDelIdx=0;
5565 RICserviceUpdate_t *ricServiceUpdate;
5566 RANfunctions_List_t *ranFunctionsList;
5567 RANfunction_ItemIEs_t *ranFuncItemIe;
5568 RANfunction_Item_t *ranFunItem;
5569 RANfunctionsID_List_t *deleteList;
5571 /* De-allocating Memory */
5572 if(e2apMsg != NULLP)
5574 if(e2apMsg->choice.initiatingMessage != NULLP)
5576 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5577 if(ricServiceUpdate->protocolIEs.list.array != NULLP)
5579 for(arrIdx = 0; arrIdx < ricServiceUpdate->protocolIEs.list.count; arrIdx++)
5581 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] != NULLP)
5583 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
5585 case ProtocolIE_IDE2_id_TransactionID:
5588 case ProtocolIE_IDE2_id_RANfunctionsAdded:
5589 case ProtocolIE_IDE2_id_RANfunctionsModified:
5591 ranFunctionsList = &(ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
5592 if(ranFunctionsList->list.array)
5594 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
5596 if(ranFunctionsList->list.array[ranFuncAddListIdx])
5598 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
5599 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
5600 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
5601 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
5602 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
5605 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
5609 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
5611 deleteList= &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5612 if(deleteList->list.array)
5614 for(ranFuncDelIdx = 0; ranFuncDelIdx< deleteList->list.count; ranFuncDelIdx++)
5616 DU_FREE(deleteList->list.array[ranFuncDelIdx], sizeof(RANfunctionID_ItemIEs_t));
5618 DU_FREE(deleteList->list.array, deleteList->list.size);
5624 DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
5625 (ricServiceUpdate->protocolIEs.list.array[arrIdx]->id));
5628 DU_FREE(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5631 DU_FREE(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5633 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5635 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5639 /*******************************************************************
5641 * @brief Builds and Send the RicServiceUpdateuest
5645 * Function : BuildAndSendRicServiceUpdate
5647 * Functionality:Fills the RicServiceUpdateuest
5649 * @return ROK - success
5652 ******************************************************************/
5654 uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate)
5656 uint16_t transId = 0;
5657 bool memAllocFailed =false;
5658 uint8_t arrIdx = 0, elementCnt=0,ret = RFAILED;
5659 E2AP_PDU_t *e2apMsg = NULLP;
5660 RICserviceUpdate_t *ricServiceUpdate = NULLP;
5661 asn_enc_rval_t encRetVal; /* Encoder return value */
5663 DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n");
5666 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5667 if(e2apMsg == NULLP)
5669 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5672 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5673 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5674 if(e2apMsg->choice.initiatingMessage == NULLP)
5676 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5679 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5680 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
5681 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceUpdate;
5682 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5684 /* For TransId IE, set elementCnt to 1.
5685 If there is any item in the RAN function add list, RAN function modification list, or RAN function delete list, increment the elementCnt.*/
5688 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5690 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5692 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5695 ricServiceUpdate->protocolIEs.list.count = elementCnt;
5696 ricServiceUpdate->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdate_IEs_t*);
5698 /* Initialize the E2Setup members */
5699 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5700 if(ricServiceUpdate->protocolIEs.list.array == NULLP)
5702 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
5706 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
5708 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5709 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP)
5711 memAllocFailed = true;
5712 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
5716 if(memAllocFailed == true)
5722 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5723 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5724 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
5725 if(serviceUpdate.dir == E2_NODE_INITIATED)
5726 transId = assignTransactionId();
5728 transId = serviceUpdate.transId;
5729 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5731 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5734 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
5735 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5736 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5737 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,\
5738 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded, serviceUpdate.recvRanFuncList.ranFunToBeAdded) !=ROK)
5744 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5747 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsModified;
5748 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5749 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5750 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,
5751 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeModified, serviceUpdate.recvRanFuncList.ranFunToBeModified) !=ROK)
5757 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5760 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsDeleted;
5761 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5762 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctionsID_List;
5763 if(BuildRanFunctionDeleteList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List,\
5764 serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted, serviceUpdate.recvRanFuncList.ranFunToBeDeleted) != ROK)
5769 /* Prints the Msg formed */
5770 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5772 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5774 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5775 if(encRetVal.encoded == ENCODE_FAIL)
5777 DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
5778 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5783 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
5784 #ifdef DEBUG_ASN_PRINT
5785 for(int i=0; i< encBufSize; i++)
5787 printf("%x",encBuf[i]);
5791 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5793 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5802 if(serviceUpdate.dir == E2_NODE_INITIATED)
5804 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5805 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5809 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId = transId;
5810 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5812 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.dir = serviceUpdate.dir;
5813 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.transId =transId;
5814 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.recvRanFuncList, &serviceUpdate.recvRanFuncList, sizeof(E2TmpRanFunList));
5816 FreeRicServiceUpdate(e2apMsg);
5819 /******************************************************************
5821 * @brief Processes RIC service Query sent by RIC
5825 * Function : procRicServiceQuery
5827 * Functionality: Processes RIC service Query sent by RIC
5829 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5830 * @return ROK - success
5833 * ****************************************************************/
5835 void procRicServiceQuery(E2AP_PDU_t *e2apMsg)
5838 uint16_t arrIdx =0, ranFuncIdx=0,tmpIdx=0;
5839 uint16_t id,revisionCcounter;
5840 bool tmpArray[MAX_RAN_FUNCTION] = {false};
5841 RICserviceQuery_t *ricServiceQuery=NULL;
5842 RicServiceUpdate ricUpdate;
5843 RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
5844 RANfunctionsID_List_t *ranFuncAddedList;
5846 DU_LOG("\nINFO --> E2AP : RIC Service Query received");
5847 memset(&ricUpdate, 0, sizeof(RicServiceUpdate));
5848 ricUpdate.dir = RIC_INITIATED;
5849 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
5851 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5853 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5855 /* TODO completing in next patch/gerrit */
5856 case ProtocolIE_IDE2_id_TransactionID:
5858 ricUpdate.transId = ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5862 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5864 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5865 if(ranFuncAddedList->list.array)
5867 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5869 if(ranFuncAddedList->list.array[ranFuncIdx])
5871 /* Using the RAN function Id, identify the RAN function to be modified or deleted. */
5873 ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
5874 id = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID;
5875 revisionCcounter = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision;
5877 if((id != duCb.e2apDb.ranFunction[id-1].id))
5879 action = CONFIG_DEL;
5881 else if((id == duCb.e2apDb.ranFunction[id-1].id)&&(revisionCcounter!=duCb.e2apDb.ranFunction[id-1].revisionCounter))
5883 action = CONFIG_MOD;
5886 if(action == CONFIG_DEL)
5888 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].id = id;
5889 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].revisionCounter = revisionCcounter;
5890 ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted++;
5892 else if(action == CONFIG_MOD)
5894 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].id = id;
5895 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].revisionCounter = revisionCcounter;
5896 ricUpdate.recvRanFuncList.numOfRanFunToBeModified++;
5899 /* If any ID is set to true, it means that the ID has been used in either modification or deletion list.
5900 * Else we will add the IDs into the added list */
5901 tmpArray[id-1] = true;
5910 /* Traversing the whole RAN function list in ducb to check if any new Ran function ids have been added. */
5911 for(arrIdx =0; arrIdx<MAX_RAN_FUNCTION; arrIdx++)
5913 tmpIdx= ricUpdate.recvRanFuncList.numOfRanFunToBeAdded;
5914 if((duCb.e2apDb.ranFunction[arrIdx].id >0)&&(!tmpArray[arrIdx]))
5916 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[arrIdx].id;
5917 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[arrIdx].revisionCounter;
5918 ricUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
5922 if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK)
5924 DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message");
5927 freeAperDecodingOfRicServiceQuery(ricServiceQuery);
5930 /******************************************************************
5932 * @brief Deallocation of memory allocated by aper decoder for
5933 * RIC service update ack
5937 * Function : freeAperDecodingOfRicServiceUpdateAck
5939 * Functionality: Deallocation of memory allocated by aper decoder
5940 * for RIC service update ack
5942 * @params[in] RICserviceUpdateAck_t *ricServiceAck;
5945 * ****************************************************************/
5947 void freeAperDecodingOfRicServiceUpdateAck(RICserviceUpdateAcknowledge_t *ricServiceAck)
5949 uint8_t arrIdx=0,ranFuncIdx=0;
5950 RANfunctionsID_List_t *ranFuncAddedList=NULL;
5954 if(ricServiceAck->protocolIEs.list.array)
5956 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5958 if(ricServiceAck->protocolIEs.list.array[arrIdx])
5960 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5962 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5964 ranFuncAddedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5965 if(ranFuncAddedList->list.array)
5967 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5969 free(ranFuncAddedList->list.array[ranFuncIdx]);
5971 free(ranFuncAddedList->list.array);
5978 free(ricServiceAck->protocolIEs.list.array[arrIdx]);
5981 free(ricServiceAck->protocolIEs.list.array);
5986 /******************************************************************
5988 * @brief Processes RIC service update ack sent by RIC
5992 * Function : procRicServiceUpdateAck
5994 * Functionality: Processes RIC service update ack sent by RIC
5996 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5997 * @return ROK - success
6000 * ****************************************************************/
6002 void procRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
6005 uint16_t transId =0;
6006 uint16_t id =0, tmpIdx=0, ranFuncIdx=0;
6007 RicServiceUpdate serviceUpdate;
6008 RANfunctionsIDcause_List_t *rejectedList=NULL;
6009 RICserviceUpdateAcknowledge_t *ricServiceAck=NULL;
6010 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
6012 DU_LOG("\nINFO --> E2AP : RIC service update ack received");
6013 memset(&serviceUpdate, 0, sizeof(RicServiceUpdate));
6014 ricServiceAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
6016 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
6018 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
6020 case ProtocolIE_IDE2_id_TransactionID:
6022 transId = ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
6023 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
6024 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
6026 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
6028 else if((duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId == transId) &&\
6029 (duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
6031 memset(&duCb.e2apDb.e2TransInfo.ricInitTransaction[transId], 0, sizeof(E2TransInfo));
6035 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
6041 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
6044 case ProtocolIE_IDE2_id_RANfunctionsRejected:
6046 rejectedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
6047 if(rejectedList->list.array)
6049 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
6051 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)rejectedList->list.array[ranFuncIdx];
6052 id = ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID;
6053 tmpIdx= serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded;
6054 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[id-1].id;
6055 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[id-1].revisionCounter;
6056 serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
6065 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
6067 serviceUpdate.dir = E2_NODE_INITIATED;
6068 BuildAndSendRicServiceUpdate(serviceUpdate);
6070 freeAperDecodingOfRicServiceUpdateAck(ricServiceAck);
6073 /******************************************************************
6075 * @brief Deallocation of memory allocated by aper decoder for
6076 * RIC service update failure
6080 * Function : freeAperDecodingOfRicServiceUpdateFailure
6082 * Functionality: Deallocation of memory allocated by aper decoder
6083 * for RIC service update failure
6085 * @params[in] RICserviceUpdateFailure_t *ricServiceFailure;
6088 * ****************************************************************/
6090 void freeAperDecodingOfRicServiceUpdateFailure(RICserviceUpdateFailure_t *ricServiceFailure)
6094 if(ricServiceFailure)
6096 if(ricServiceFailure->protocolIEs.list.array)
6098 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6100 if(ricServiceFailure->protocolIEs.list.array[arrIdx])
6102 free(ricServiceFailure->protocolIEs.list.array[arrIdx]);
6105 free(ricServiceFailure->protocolIEs.list.array);
6110 /******************************************************************
6112 * @brief Processes RIC service update failure sent by RIC
6116 * Function : procRicServiceUpdateFailure
6118 * Functionality: Processes RIC service update failure sent by RIC
6120 * @params[in] E2AP_PDU_t ASN decoded E2AP message
6121 * @return ROK - success
6124 * ****************************************************************/
6126 void procRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
6128 uint8_t arrIdx =0, timerValue=0;
6129 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
6131 DU_LOG("\nINFO --> E2AP : RIC service update failure received");
6132 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
6134 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6136 switch(ricServiceFailure->protocolIEs.list.array[arrIdx]->id)
6138 case ProtocolIE_IDE2_id_TransactionID:
6142 case ProtocolIE_IDE2_id_TimeToWaitE2:
6144 timerValue = convertE2WaitTimerEnumToValue(ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
6145 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR)) == FALSE)
6147 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR, timerValue);
6151 DU_LOG("\nERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running");
6156 case ProtocolIE_IDE2_id_CauseE2:
6163 freeAperDecodingOfRicServiceUpdateFailure(ricServiceFailure);
6166 /******************************************************************
6168 * @brief DU Send E2 Node Configuration Update
6172 * Function : duSendE2NodeConfigurationUpdate
6174 * Functionality: DU Send E2 Node Configuration Update
6176 * @return ROK - success
6179 * ****************************************************************/
6181 uint8_t duSendE2NodeConfigurationUpdate()
6183 E2NodeConfigList e2NodeList;
6184 CmLList *node =NULL;
6185 E2NodeComponent *e2NodeComponentInfo=NULL;
6187 memset(&e2NodeList, 0, sizeof(E2NodeConfigList));
6188 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
6191 e2NodeComponentInfo = (E2NodeComponent*)node->node;
6193 if(e2NodeComponentInfo->addConfiguration)
6195 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6196 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6197 e2NodeList.addE2NodeCount++;
6200 if(e2NodeComponentInfo->updateConfiguration)
6202 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6203 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6204 e2NodeList.updateE2NodeCount++;
6207 if(e2NodeComponentInfo->deleteConfiguration == true)
6209 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6210 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].componentId = e2NodeComponentInfo->componentId;
6211 e2NodeList.removeE2NodeCount++;
6217 if(BuildAndSendE2NodeConfigUpdate(&e2NodeList) !=ROK)
6219 DU_LOG("\nERROR --> E2AP : Failed to build and send e2 node config update message to RIC_stub");
6225 /*******************************************************************
6227 * @brief Free RIC Subscription Modification Required
6231 * Function : FreeRicSubsModRequired
6233 * Functionality: Freqq RIC Subscription Modification required
6235 * @param E2AP Message PDU to be freed
6238 ******************************************************************/
6239 void FreeRicSubsModRequired(E2AP_PDU_t *e2apMsg)
6241 uint8_t ieIdx = 0, arrIdx = 0;
6242 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6243 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6244 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6245 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6249 if(e2apMsg->choice.initiatingMessage)
6251 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6252 if(ricSubsModReqd->protocolIEs.list.array)
6254 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
6256 if(ricSubsModReqd->protocolIEs.list.array[ieIdx])
6258 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6259 switch(ricSubsModReqdIe->id)
6261 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
6263 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6264 if(actionToBeModList->list.array)
6266 for(arrIdx = 0; arrIdx < actionToBeModList->list.count; arrIdx++)
6268 DU_FREE(actionToBeModList->list.array[arrIdx], \
6269 sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6271 DU_FREE(actionToBeModList->list.array, actionToBeModList->list.size);
6276 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
6278 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6279 if(actionToBeRmvList->list.array)
6281 for(arrIdx = 0; arrIdx < actionToBeRmvList->list.count; arrIdx++)
6283 DU_FREE(actionToBeRmvList->list.array[arrIdx], \
6284 sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6286 DU_FREE(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6294 DU_FREE(ricSubsModReqd->protocolIEs.list.array[ieIdx], \
6295 sizeof(RICsubscriptionModificationRequired_IEs_t));
6298 DU_FREE(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6300 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6302 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6306 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6307 * However, E2SM-KPM supports only RIC Report service.
6308 * Hence there is no subsequent action in RIC subscription that may require modification.
6309 * So commenting the action-modification IEs for the time being
6312 /*******************************************************************
6314 * @brief Fill Action required to be modified list
6318 * Function : FillActionReqdToBeModList
6320 * Functionality: Fill Action required to be modified list
6322 * @param RIC Actions Required To Be Modified List to be filled
6323 * Number of actions to be modified
6324 * RIC Subscription DB
6325 * @return ROK - success
6328 ******************************************************************/
6329 uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod,\
6330 RicSubscription *ricSubscription)
6333 CmLList *actionNode = NULLP;
6334 ActionInfo *actionDb = NULLP;
6335 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL;
6337 actionToBeModList->list.count = numActionsMod;
6338 actionToBeModList->list.size = numActionsMod * sizeof(RICaction_RequiredToBeModified_ItemIEs_t *);
6339 DU_ALLOC(actionToBeModList->list.array, actionToBeModList->list.size);
6340 if(!actionToBeModList->list.array)
6342 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6347 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6350 actionDb = (ActionInfo*)(actionNode->node);
6351 if(actionDb->action == CONFIG_MOD)
6353 DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6354 if(!actionToBeModList->list.array[arrIdx])
6356 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6359 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[arrIdx];
6361 actionToBeMod->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeModified_Item;
6362 actionToBeMod->criticality = CriticalityE2_reject;
6363 actionToBeMod->value.present = \
6364 RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item;
6365 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \
6367 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms;
6376 /*******************************************************************
6378 * @brief Fill Action required to be removed list
6382 * Function : FillActionReqdToBeRmvList
6384 * Functionality: Fill Action required to be removed list
6386 * @param RIC Actions Required To Be Removed List to be filled
6387 * Number of actions to be removed
6388 * RIC Subscription DB
6389 * @return ROK - success
6392 ******************************************************************/
6393 uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \
6394 RicSubscription *ricSubscription)
6397 CmLList *actionNode = NULLP;
6398 ActionInfo *actionDb = NULLP;
6399 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL;
6401 actionToBeRmvList->list.count = numActionsRmv;
6402 actionToBeRmvList->list.size = numActionsRmv * sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t *);
6403 DU_ALLOC(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6404 if(!actionToBeRmvList->list.array)
6406 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6411 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6414 actionDb = (ActionInfo*)(actionNode->node);
6415 if(actionDb->action == CONFIG_DEL)
6417 DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6418 if(!actionToBeRmvList->list.array[arrIdx])
6420 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6423 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[arrIdx];
6425 actionToBeRmv->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeRemoved_Item;
6426 actionToBeRmv->criticality = CriticalityE2_reject;
6427 actionToBeRmv->value.present = \
6428 RICaction_RequiredToBeRemoved_ItemIEs__value_PR_RICaction_RequiredToBeRemoved_Item;
6429 actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = actionDb->actionId;
6430 fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, actionDb->failureCause);
6438 /*******************************************************************
6440 * @brief Fill RIC Subscription Modification Required IEs
6444 * Function : FillRicSubsModRequired
6446 * Functionality: Fill RIC Subscription Modification Required IEs
6448 * @param RIC Subscription Modification Required IEs to be filled
6449 * RIC Subscription DB
6450 * @return ROK - success
6453 ******************************************************************/
6454 uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription)
6456 ActionInfo * actionDb=NULLP;
6457 CmLList *actionNode = NULLP;
6458 uint8_t ieIdx = 0, elementCnt=0;
6459 uint8_t numActionsMod = 0, numActionsRmv = 0;
6460 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6461 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6463 /* Unused in case of E2SM-KPM */
6465 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6468 /* Count number of Actions to be modified or deleted */
6469 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6472 actionDb = (ActionInfo*)(actionNode->node);
6473 if(actionDb->action == CONFIG_MOD)
6475 else if(actionDb->action == CONFIG_DEL)
6477 actionNode = actionNode->next;
6480 /* Count number of IEs to be added to messages */
6487 ricSubsModReqd->protocolIEs.list.count = elementCnt;
6488 ricSubsModReqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequired_IEs_t *);
6489 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6490 if(!ricSubsModReqd->protocolIEs.list.array)
6492 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6496 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
6498 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRequired_IEs_t));
6499 if(!ricSubsModReqd->protocolIEs.list.array[ieIdx])
6501 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6506 /* RIC Request ID */
6508 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6509 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICrequestID;
6510 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6511 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RICrequestID;
6512 ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID = ricSubscription->requestId.requestorId;
6513 ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID = ricSubscription->requestId.instanceId;
6515 /* RAN Function ID */
6517 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6518 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RANfunctionID;
6519 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6520 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RANfunctionID;
6521 ricSubsModReqdIe->value.choice.RANfunctionID = ricSubscription->ranFuncId;
6523 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6524 * However, E2SM-KPM supports only RIC Report service.
6525 * Hence there is no subsequent action in RIC subscription that may require modification.
6526 * So commenting the action-modification IEs for the time being
6529 /* RIC Actions Required to be Modified */
6533 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6534 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List;
6535 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6536 ricSubsModReqdIe->value.present = \
6537 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeModified_List;
6538 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6540 if(FillActionReqdToBeModList(actionToBeModList, numActionsMod, ricSubscription) != ROK)
6542 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__);
6548 /* RIC Actions Required to be removed */
6552 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6553 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List;
6554 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6555 ricSubsModReqdIe->value.present = \
6556 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeRemoved_List;
6557 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6559 if(FillActionReqdToBeRmvList(actionToBeRmvList, numActionsRmv, ricSubscription) != ROK)
6561 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__);
6569 /*******************************************************************
6571 * @brief Builds and Send RIC Subscription Modification Required
6576 * Function : BuildAndSendRicSubsModRequired
6578 * Functionality: Builds and Send RIC Subscription Modification
6581 * @param RIC Subscription DB
6582 * @return ROK - success
6585 ******************************************************************/
6586 uint8_t BuildAndSendRicSubsModRequired(RicSubscription *ricSubscription)
6588 uint8_t ret = RFAILED;
6589 E2AP_PDU_t *e2apMsg = NULLP;
6590 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6591 asn_enc_rval_t encRetVal; /* Encoder return value */
6593 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Required \n");
6596 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6597 if(e2apMsg == NULLP)
6599 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6603 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6604 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6605 if(e2apMsg->choice.initiatingMessage == NULLP)
6607 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6610 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6611 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
6612 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired;
6614 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6616 if(FillRicSubsModRequired(ricSubsModReqd, ricSubscription) != ROK)
6618 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__);
6623 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6625 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6627 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6628 if(encRetVal.encoded == ENCODE_FAIL)
6630 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modifiction Required structure (at %s)\n",\
6631 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6636 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Required \n");
6637 #ifdef DEBUG_ASN_PRINT
6638 for(int i=0; i< encBufSize; i++)
6640 printf("%x",encBuf[i]);
6644 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
6646 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Modification Required failed");
6653 /* Free RIC Subscription modification required */
6654 FreeRicSubsModRequired(e2apMsg);
6658 /*******************************************************************
6660 * @brief Free APER decoding of RIC Subscription Modification Confirm
6664 * Function : freeAperDecodingOfRicSubsModConfirm
6666 * Functionality: Free APER decoding of RIC Subscription
6667 * Modification Confirm
6669 * @param E2AP Message PDU
6672 ******************************************************************/
6673 void freeAperDecodingOfRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
6675 uint8_t ieIdx = 0, arrIdx=0;
6676 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6677 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6678 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6679 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6680 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6681 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6683 if(e2apMsg && e2apMsg->choice.successfulOutcome)
6685 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6686 if(ricSubsModCfm->protocolIEs.list.array)
6688 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6690 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
6692 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6693 switch(ricSubsModCfmIe->id)
6695 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6697 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6698 if(modCfmList->list.array)
6700 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6702 if(modCfmList->list.array[arrIdx])
6703 free(modCfmList->list.array[arrIdx]);
6705 free(modCfmList->list.array);
6710 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6712 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6713 if(modRefusedList->list.array)
6715 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6717 if(modRefusedList->list.array[arrIdx])
6718 free(modRefusedList->list.array[arrIdx]);
6720 free(modRefusedList->list.array);
6725 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6727 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6728 if(rmvCfmList->list.array)
6730 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6732 if(rmvCfmList->list.array[arrIdx])
6733 free(rmvCfmList->list.array[arrIdx]);
6735 free(rmvCfmList->list.array);
6740 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6742 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6743 if(rmvFailList->list.array)
6745 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6747 if(rmvFailList->list.array[arrIdx])
6748 free(rmvFailList->list.array[arrIdx]);
6750 free(rmvFailList->list.array);
6759 free(ricSubsModCfmIe);
6762 free(ricSubsModCfm->protocolIEs.list.array);
6767 /*******************************************************************
6769 * @brief Process RIC Subscription Modification Confirm Message
6773 * Function : procRicSubscriptionModificationConfirm
6775 * Functionality: Process RIC Subscription Modification Confirm
6776 * Message received from RIC.
6778 * @param E2AP Message PDU
6781 ******************************************************************/
6782 void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg)
6784 uint8_t actionId = 0, ieIdx = 0, arrIdx = 0;
6785 uint16_t ranFuncId = 0;
6786 bool procFailure = false;
6787 RicRequestId ricReqId;
6788 RanFunction *ranFuncDb = NULLP;
6789 CmLList *ricSubsNode = NULLP;
6790 CmLList *actionNode= NULLP;
6791 RicSubscription *ricSubsDb = NULLP;
6792 ActionInfo *actionDb = NULLP;
6794 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6795 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6797 /* Not used in case of E2SM-KPM */
6799 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6800 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
6802 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6803 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
6806 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6807 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
6809 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6810 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
6812 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Confirm", __func__);
6817 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
6821 if(!e2apMsg->choice.successfulOutcome)
6823 DU_LOG("\nERROR --> E2AP : %s: Successful Outcome in E2AP message is NULL", __func__);
6827 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6828 if(!ricSubsModCfm->protocolIEs.list.array)
6830 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
6834 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6836 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
6838 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
6842 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6843 switch(ricSubsModCfmIe->id)
6845 case ProtocolIE_IDE2_id_RICrequestID:
6847 memset(&ricReqId, 0, sizeof(RicRequestId));
6848 ricReqId.requestorId = ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID;
6849 ricReqId.instanceId = ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID;
6853 case ProtocolIE_IDE2_id_RANfunctionID:
6855 ranFuncId = ricSubsModCfmIe->value.choice.RANfunctionID;
6856 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
6859 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
6864 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
6867 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
6868 __func__, ricReqId.requestorId, ricReqId.instanceId);
6876 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6877 * However, E2SM-KPM supports only RIC Report service.
6878 * Hence there is no subsequent action in RIC subscription that may require modification.
6879 * So commenting the action-modification IEs for the time being
6882 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6884 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6885 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6887 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
6888 actionId = modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID;
6890 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6893 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6897 actionDb->action = CONFIG_UNKNOWN;
6898 /* Further handling can be added here in future once the
6899 * use case of this procedure is identified */
6906 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6908 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6909 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6911 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
6912 actionId = modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID;
6913 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6916 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6920 /* Spec doesnt mention if in case of failure, DU should retry for modify action
6921 * Hence, chaging the action from CONFIG_MOD to CONFIG_UNKNOWN
6923 actionDb->action = CONFIG_UNKNOWN;
6931 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6933 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6934 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6936 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
6937 actionId = rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID;
6938 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6941 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6945 cmLListDelFrm(&ricSubsDb->actionSequence, actionNode);
6946 deleteActionSequence(actionNode);
6948 /* Further handling can include :
6949 * Deletion of this action from all DU layers
6957 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6959 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6960 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6962 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
6963 actionId = rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID;
6964 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6967 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6971 actionDb->action = CONFIG_UNKNOWN;
6980 } /* End of switch for Protocol IE Id */
6984 } /* End of for loop for Protocol IE list */
6989 freeAperDecodingOfRicSubsModConfirm(e2apMsg);
6993 /******************************************************************
6994 * @brief Deallocate the memory allocated for E2 Reset Response
6998 * Function : FreeE2ResetResponse
7001 * - freeing the memory allocated for E2ResetResponse
7003 * @params[in] E2AP_PDU_t *e2apMsg
7004 * @return ROK - success
7007 * ****************************************************************/
7008 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
7011 ResetResponseE2_t *resetResponse;
7013 if(e2apMsg != NULLP)
7015 if(e2apMsg->choice.successfulOutcome != NULLP)
7017 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
7018 if(resetResponse->protocolIEs.list.array)
7020 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
7022 if(resetResponse->protocolIEs.list.array[ieIdx])
7024 DU_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
7027 DU_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
7030 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7032 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
7036 /*******************************************************************
7038 * @brief Buld and send the E2 Reset Response msg
7042 * Function : BuildAndSendE2ResetResponse
7045 * - Buld and send the E2 Reset Response Message
7047 * @params[in] Trans Id
7048 * @return ROK - success
7051 * ****************************************************************/
7052 uint8_t BuildAndSendResetResponse(uint16_t transId)
7054 uint8_t ieIdx = 0, elementCnt = 0;
7055 uint8_t ret = RFAILED;
7056 E2AP_PDU_t *e2apMsg = NULLP;
7057 ResetResponseE2_t *resetResponse;
7058 asn_enc_rval_t encRetVal; /* Encoder return value */
7060 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
7063 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7064 if(e2apMsg == NULLP)
7066 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
7069 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7071 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7072 if(e2apMsg->choice.successfulOutcome == NULLP)
7074 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
7078 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
7079 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7080 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
7081 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
7084 resetResponse->protocolIEs.list.count = elementCnt;
7085 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
7086 DU_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
7087 if(!resetResponse->protocolIEs.list.array)
7089 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
7093 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
7095 DU_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
7096 if(!resetResponse->protocolIEs.list.array[ieIdx])
7098 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
7102 if(ieIdx < elementCnt)
7106 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
7107 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
7108 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
7109 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
7111 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7113 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7115 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7116 if(encRetVal.encoded == ENCODE_FAIL)
7118 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
7119 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7124 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
7125 for(int i=0; i< encBufSize; i++)
7127 DU_LOG("%x",encBuf[i]);
7132 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7134 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
7142 FreeE2ResetResponse(e2apMsg);
7146 /******************************************************************
7148 * @brief Deallocation of memory allocated by aper decoder for reset req
7152 * Function : freeAperDecodingOfE2ResetReq
7154 * Functionality: Deallocation of memory allocated by aper decoder for
7157 * @params[in] Pointer to resetReq
7160 * ****************************************************************/
7161 void freeAperDecodingOfE2ResetReq(ResetRequestE2_t *resetReq)
7167 if(resetReq->protocolIEs.list.array)
7169 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7171 if(resetReq->protocolIEs.list.array[arrIdx])
7173 free(resetReq->protocolIEs.list.array[arrIdx]);
7176 free(resetReq->protocolIEs.list.array);
7181 /*******************************************************************
7183 * @brief Process reset req received from RIC
7187 * Function : procE2ResetRequest
7189 * Functionality: Process reset req received from RIC
7191 * @param E2AP_PDU_t *e2apMsg
7194 ******************************************************************/
7196 void procE2ResetRequest(E2AP_PDU_t *e2apMsg)
7199 uint16_t transId =0;
7200 uint16_t ranFuncIdx=0;
7201 ResetRequestE2_t *resetReq;
7203 DU_LOG("\nINFO --> E2AP : E2 Reset request received");
7204 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
7206 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7208 switch(resetReq->protocolIEs.list.array[arrIdx]->id)
7210 case ProtocolIE_IDE2_id_TransactionID:
7212 transId = resetReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
7216 case ProtocolIE_IDE2_id_CauseE2:
7218 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
7220 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
7222 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
7223 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
7230 if(BuildAndSendResetResponse(transId) != ROK)
7232 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
7234 freeAperDecodingOfE2ResetReq(resetReq);
7237 /*******************************************************************
7239 * @brief Free APER decoding of RIC Subscription Modification Refuse
7243 * Function : freeAperDecodingOfRicSubsModRefuse
7245 * Functionality: Free APER decoding of RIC Subscription
7246 * Modification Refuse
7248 * @param E2AP Message PDU
7251 ******************************************************************/
7252 void freeAperDecodingOfRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
7255 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7257 if(e2apMsg && e2apMsg->choice.unsuccessfulOutcome)
7259 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7260 if(ricSubsModRefuse->protocolIEs.list.array)
7262 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7264 if(ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7265 free(ricSubsModRefuse->protocolIEs.list.array[ieIdx]);
7267 free(ricSubsModRefuse->protocolIEs.list.array);
7272 /*******************************************************************
7274 * @brief Process RIC Subscription Modification Refuse Message
7278 * Function : procRicSubscriptionModificationRefuse
7280 * Functionality: Process RIC Subscription Modification Refuse
7281 * Message received from RIC.
7283 * @param E2AP Message PDU
7286 ******************************************************************/
7287 void procRicSubscriptionModificationRefuse(E2AP_PDU_t *e2apMsg)
7290 uint16_t ranFuncId = 0;
7291 RicRequestId ricReqId;
7292 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7293 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
7294 CauseE2_t *cause = NULLP;
7296 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Refuse", __func__);
7301 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
7305 if(!e2apMsg->choice.unsuccessfulOutcome)
7307 DU_LOG("\nERROR --> E2AP : %s: Unsuccessful Outcome in E2AP message is NULL", __func__);
7311 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7312 if(!ricSubsModRefuse->protocolIEs.list.array)
7314 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
7318 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7320 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7322 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
7326 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
7327 switch(ricSubsModRefuseIe->id)
7329 case ProtocolIE_IDE2_id_RICrequestID:
7331 memset(&ricReqId, 0, sizeof(RicRequestId));
7332 ricReqId.requestorId = ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID;
7333 ricReqId.instanceId = ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID;
7337 case ProtocolIE_IDE2_id_RANfunctionID:
7339 ranFuncId = ricSubsModRefuseIe->value.choice.RANfunctionID;
7343 case ProtocolIE_IDE2_id_CauseE2:
7345 DU_LOG("\nDEBUG --> E2AP : %s: RIC subscriptiom modification refused for RIC_Requestor_ID [%d] \
7346 RIC_Instance_ID [%d] RAN_Function_ID [%d] ", __func__, ricReqId.requestorId, \
7347 ricReqId.instanceId, ranFuncId);
7349 cause = &ricSubsModRefuseIe->value.choice.CauseE2;
7350 printE2ErrorCause(cause);
7355 } /* End of switch for Protocol IE Id */
7356 } /* End of for loop for Protocol IE list */
7361 freeAperDecodingOfRicSubsModRefuse(e2apMsg);
7365 /*******************************************************************
7367 * @brief Free RIC Subscription Delete Required Message
7371 * Function : FreeRicSubscriptionDeleteRequired
7373 * Functionality: Free RIC Subscription Delete Required
7375 * @param E2AP Message PDU
7378 ******************************************************************/
7379 void FreeRicSubscriptionDeleteRequired(E2AP_PDU_t *e2apMsg, CmLListCp *ricSubsToBeDelList)
7381 uint8_t ieIdx = 0, arrIdx = 0;
7382 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7383 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7384 RICsubscription_List_withCause_t *ricSubsList = NULLP;
7385 CmLList *subsNode = NULLP;
7389 if(e2apMsg->choice.initiatingMessage)
7391 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7392 if(ricSubsDelRqd->protocolIEs.list.array)
7394 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
7396 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx])
7398 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7399 switch(ricSubsDelRqdIe->id)
7401 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
7403 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
7404 if(ricSubsList->list.array)
7406 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
7408 DU_FREE(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7410 DU_FREE(ricSubsList->list.array, ricSubsList->list.size);
7415 DU_FREE(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7418 DU_FREE(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7420 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7422 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7425 if(ricSubsToBeDelList)
7427 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7430 cmLListDelFrm(ricSubsToBeDelList, subsNode);
7431 DU_FREE(subsNode, sizeof(CmLList));
7432 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7437 /*******************************************************************
7439 * @brief Fill list of RIC subscriptions required to be deleted
7440 * with the cause of deletion
7444 * Function : fillRicSubsListWithCause
7446 * Functionality: Fill list of RIC subscriptions required to be
7447 * deleted with the cause of deletion
7449 * @param E2AP Message PDU
7452 ******************************************************************/
7453 uint8_t fillRicSubsListWithCause(RICsubscription_List_withCause_t *ricSubsList, CmLListCp ricSubsToBeDelList)
7456 CmLList *subsNode = NULLP;
7457 RicSubscription *subsInfo = NULLP;
7458 RICsubscription_withCause_ItemIEs_t *subsItemIe = NULLP;
7459 RICsubscription_withCause_Item_t *subsItem = NULLP;
7461 ricSubsList->list.count = ricSubsToBeDelList.count;
7462 ricSubsList->list.size = ricSubsList->list.count * sizeof(RICsubscription_withCause_ItemIEs_t *);
7463 DU_ALLOC(ricSubsList->list.array, ricSubsList->list.size);
7464 if(!ricSubsList->list.array)
7466 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7470 CM_LLIST_FIRST_NODE(&ricSubsToBeDelList, subsNode);
7471 while(subsNode && (ieIdx < ricSubsList->list.count))
7473 subsInfo = (RicSubscription *)subsNode->node;
7474 DU_ALLOC(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7475 if(!ricSubsList->list.array[ieIdx])
7477 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7481 subsItemIe = (RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[ieIdx];
7482 subsItemIe->id = ProtocolIE_IDE2_id_RICsubscription_withCause_Item;
7483 subsItemIe->criticality = CriticalityE2_ignore;
7484 subsItemIe->value.present = RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item;
7486 subsItem = & subsItemIe->value.choice.RICsubscription_withCause_Item;
7487 subsItem->ricRequestID.ricRequestorID = subsInfo->requestId.requestorId;
7488 subsItem->ricRequestID.ricInstanceID = subsInfo->requestId.instanceId;
7489 subsItem->ranFunctionID = subsInfo->ranFuncId;
7490 fillE2Cause(&subsItem->cause, subsInfo->failureCause);
7493 subsNode = subsNode->next;
7499 /*******************************************************************
7501 * @brief Builds and Send RIC Subscription delete required
7505 * Function : BuildAndSendRicSubscriptionDeleteRequired
7507 * Functionality: Build and send RIC subscription delete required.
7508 * There can be 2 approaches to trigger following. One of these
7509 * approaches may/may not be implemented in future:
7510 * 1. It can be triggerred immediately when a RIC subscription's
7511 * End Time has expired. In this case, only this subscription's
7512 * info will be sent in this message.
7513 * Since we have not yet added support to execute RIC
7514 * Subscription based on Start Time and End Timer, this message is
7515 * not triggered anywhere from DU APP yet.
7516 * 2. Another approach is to have a periodic timer to check subscription
7517 * status running in background.
7518 * When RIC Subscription End Time expires, this subscription is
7519 * marked to be deleted. Later when this background timer expires,
7520 * a RIC Subscription delete required is sent with all the
7521 * subscription's info which is marked to be deleted.
7522 * The following function is implemented keeping in mind the second
7526 * @return ROK - success
7529 ******************************************************************/
7530 uint8_t BuildAndSendRicSubscriptionDeleteRequired()
7532 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7533 E2AP_PDU_t *e2apMsg = NULLP;
7534 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7535 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7536 asn_enc_rval_t encRetVal; /* Encoder return value */
7537 CmLListCp ricSubsToBeDelList;
7541 /* Check if there are any RIC subscriptions to be deleted */
7542 cmLListInit(&ricSubsToBeDelList);
7543 fetchRicSubsToBeDeleted(&ricSubsToBeDelList);
7544 if(ricSubsToBeDelList.count == 0)
7546 DU_LOG("\nDEBUG --> E2AP : %s: No RIC subscriptions are required to be deleted", __func__);
7550 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Required Message\n");
7552 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7553 if(e2apMsg == NULLP)
7555 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7559 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
7560 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7561 if(e2apMsg->choice.initiatingMessage == NULLP)
7563 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7566 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDeleteRequired;
7567 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
7568 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired;
7570 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7573 ricSubsDelRqd->protocolIEs.list.count = elementCnt;
7574 ricSubsDelRqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequired_IEs_t *);
7576 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7577 if(ricSubsDelRqd->protocolIEs.list.array == NULLP)
7579 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7583 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7585 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7586 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx] == NULLP)
7588 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7589 __func__, ieIdx, __LINE__);
7593 if(ieIdx < elementCnt)
7597 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7598 ricSubsDelRqdIe->id = ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved;
7599 ricSubsDelRqdIe->criticality = CriticalityE2_ignore;
7600 ricSubsDelRqdIe->value.present = RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause;
7601 if(fillRicSubsListWithCause(&ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause, ricSubsToBeDelList)\
7604 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription list with cause", __func__);
7608 /* Prints the Msg formed */
7609 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7610 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7612 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7613 if(encRetVal.encoded == ENCODE_FAIL)
7615 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Required Message (at %s)\n",\
7616 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7621 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Required Message \n");
7622 #ifdef DEBUG_ASN_PRINT
7623 for(int i=0; i< encBufSize; i++)
7625 printf("%x",encBuf[i]);
7630 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7632 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Required Message");
7639 FreeRicSubscriptionDeleteRequired(e2apMsg, &ricSubsToBeDelList);
7643 /*******************************************************************
7645 * @brief Free RIC Subscription Delete Failure Message
7649 * Function : FreeRicSubscriptionDeleteFailure
7651 * Functionality: Free RIC Subscription Delete Failure
7653 * @param E2AP Message PDU
7656 ******************************************************************/
7657 void FreeRicSubscriptionDeleteFailure(E2AP_PDU_t *e2apMsg)
7660 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7664 if(e2apMsg->choice.unsuccessfulOutcome)
7666 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7667 if(ricSubsDelFailure->protocolIEs.list.array)
7669 for(ieIdx = 0; ieIdx < ricSubsDelFailure->protocolIEs.list.count; ieIdx++)
7671 DU_FREE(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7673 DU_FREE(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7675 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7677 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7681 /*******************************************************************
7683 * @brief Builds and Send RIC Subscription Delete Failure
7687 * Function : BuildAndSendRicSubscriptionDeleteFailure
7689 * Functionality: Build and send RIC Subscription Delete Failure.
7695 * @return ROK - success
7698 ******************************************************************/
7699 uint8_t BuildAndSendRicSubscriptionDeleteFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
7701 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7702 E2AP_PDU_t *e2apMsg = NULLP;
7703 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7704 RICsubscriptionDeleteFailure_IEs_t *ricSubsDelFailureIe = NULLP;
7705 asn_enc_rval_t encRetVal; /* Encoder return value */
7709 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Failure Message\n");
7711 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7712 if(e2apMsg == NULLP)
7714 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7718 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
7719 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7720 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
7722 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7725 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7726 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
7727 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteFailure;
7730 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7733 ricSubsDelFailure->protocolIEs.list.count = elementCnt;
7734 ricSubsDelFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteFailure_IEs_t *);
7736 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7737 if(ricSubsDelFailure->protocolIEs.list.array == NULLP)
7739 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7743 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7745 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7746 if(ricSubsDelFailure->protocolIEs.list.array[ieIdx] == NULLP)
7748 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7749 __func__, ieIdx, __LINE__);
7753 if(ieIdx < elementCnt)
7757 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7758 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
7759 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7760 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
7761 ricSubsDelFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7762 ricSubsDelFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7765 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7766 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7767 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7768 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
7769 ricSubsDelFailureIe->value.choice.RANfunctionID = ranFuncId;
7772 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7773 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
7774 ricSubsDelFailureIe->criticality = CriticalityE2_ignore;
7775 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_CauseE2;
7776 fillE2Cause(&ricSubsDelFailureIe->value.choice.CauseE2, failureCause);
7778 /* Prints the Msg formed */
7779 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7780 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7782 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7783 if(encRetVal.encoded == ENCODE_FAIL)
7785 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Failure Message (at %s)\n",\
7786 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7791 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Failure Message \n");
7792 #ifdef DEBUG_ASN_PRINT
7793 for(int i=0; i< encBufSize; i++)
7795 printf("%x",encBuf[i]);
7800 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7802 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Failure Message");
7810 FreeRicSubscriptionDeleteFailure(e2apMsg);
7815 /*******************************************************************
7817 * @brief Free RIC Subscription Delete Response Message
7821 * Function : FreeRicSubscriptionDeleteResponse
7823 * Functionality: Free RIC Subscription Delete Response
7825 * @param E2AP Message PDU
7828 ******************************************************************/
7829 void FreeRicSubscriptionDeleteResponse(E2AP_PDU_t *e2apMsg)
7832 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7836 if(e2apMsg->choice.successfulOutcome)
7838 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7839 if(ricSubsDelRsp->protocolIEs.list.array)
7841 for(ieIdx = 0; ieIdx < ricSubsDelRsp->protocolIEs.list.count; ieIdx++)
7843 DU_FREE(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7845 DU_FREE(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7847 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7849 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7853 /*******************************************************************
7855 * @brief Builds and Send RIC Subscription delete Response
7859 * Function : BuildAndSendRicSubscriptionDeleteResponse
7861 * Functionality: Build and send RIC subscription delete Response.
7866 * @return ROK - success
7869 ******************************************************************/
7870 uint8_t BuildAndSendRicSubscriptionDeleteResponse(uint16_t ranFuncId, RicRequestId requestId)
7872 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7873 E2AP_PDU_t *e2apMsg = NULLP;
7874 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7875 RICsubscriptionDeleteResponse_IEs_t *ricSubsDelRspIe = NULLP;
7876 asn_enc_rval_t encRetVal; /* Encoder return value */
7880 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Response Message\n");
7882 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7883 if(e2apMsg == NULLP)
7885 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7889 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7890 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7891 if(e2apMsg->choice.successfulOutcome == NULLP)
7893 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7896 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7897 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7898 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse;
7901 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7904 ricSubsDelRsp->protocolIEs.list.count = elementCnt;
7905 ricSubsDelRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteResponse_IEs_t *);
7907 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7908 if(ricSubsDelRsp->protocolIEs.list.array == NULLP)
7910 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7914 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7916 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7917 if(ricSubsDelRsp->protocolIEs.list.array[ieIdx] == NULLP)
7919 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7920 __func__, ieIdx, __LINE__);
7924 if(ieIdx < elementCnt)
7928 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7929 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
7930 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7931 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
7932 ricSubsDelRspIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7933 ricSubsDelRspIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7936 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7937 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7938 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7939 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
7940 ricSubsDelRspIe->value.choice.RANfunctionID = ranFuncId;
7942 /* Prints the Msg formed */
7943 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7944 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7946 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7947 if(encRetVal.encoded == ENCODE_FAIL)
7949 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Response Message (at %s)\n",\
7950 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7955 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Response Message \n");
7956 #ifdef DEBUG_ASN_PRINT
7957 for(int i=0; i< encBufSize; i++)
7959 printf("%x",encBuf[i]);
7964 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7966 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Response Message");
7974 FreeRicSubscriptionDeleteResponse(e2apMsg);
7978 /*******************************************************************
7980 * @brief Free RIC Subscription Delete Request Message
7984 * Function : freeAperDecodingOfRicSubsDeleteReq
7986 * Functionality: Free RIC Subscription Delete Request
7988 * @param E2AP Message PDU
7991 ******************************************************************/
7992 void freeAperDecodingOfRicSubsDeleteReq(E2AP_PDU_t *e2apMsg)
7995 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
7999 if(e2apMsg->choice.initiatingMessage)
8001 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
8002 if(ricSubsDelReq->protocolIEs.list.array)
8004 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
8006 if(ricSubsDelReq->protocolIEs.list.array[ieIdx])
8008 free(ricSubsDelReq->protocolIEs.list.array[ieIdx]);
8011 free(ricSubsDelReq->protocolIEs.list.array);
8017 /*******************************************************************
8019 * @brief Process RIC Subscription delete request
8023 * Function : procRicSubscriptionDeleteRequest
8025 * Functionality: Process RIC subscription delete request.
8026 * Fetch RAN Function and RIC subscription to be deleted.
8027 * Send statistics delete request to MAC for all action sequence
8028 * within this RIC subscription.
8030 * @params[in] E2AP PDU
8033 ******************************************************************/
8034 void procRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
8037 uint16_t ranFuncId = 0;
8038 bool procFailure = false;
8039 RicRequestId ricReqId;
8040 RanFunction *ranFuncDb = NULLP;
8041 CmLList *ricSubsNode = NULLP;
8042 RicSubscription *ricSubsDb = NULLP;
8043 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
8044 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
8046 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Delete Request", __func__);
8051 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
8055 if(!e2apMsg->choice.initiatingMessage)
8057 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
8061 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
8062 if(!ricSubsDelReq->protocolIEs.list.array)
8064 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
8068 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
8070 if(!ricSubsDelReq->protocolIEs.list.array[ieIdx])
8072 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
8076 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
8077 switch(ricSubsDelReqIe->id)
8079 case ProtocolIE_IDE2_id_RICrequestID:
8081 memset(&ricReqId, 0, sizeof(RicRequestId));
8082 ricReqId.requestorId = ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID;
8083 ricReqId.instanceId = ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID;
8087 case ProtocolIE_IDE2_id_RANfunctionID:
8089 ranFuncId = ricSubsDelReqIe->value.choice.RANfunctionID;
8090 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
8093 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
8098 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
8101 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
8102 __func__, ricReqId.requestorId, ricReqId.instanceId);
8107 if(BuildAndSendStatsDeleteReq(ricSubsDb, true) != ROK)
8109 DU_LOG("\nERROR --> E2AP : Failed to build and send ric subscription delete req to du layers");
8116 } /* End of switch for Protocol IE Id */
8120 } /* End of for loop for Protocol IE list */
8125 freeAperDecodingOfRicSubsDeleteReq(e2apMsg);
8129 /*******************************************************************
8131 * @brief Deallocate the memory allocated for E2 node configuration
8132 * update ack msg by aper decoder
8136 * Function : freeAperDecodingOfE2NodeConfigUpdateAck
8139 * - Deallocate the memory allocated for E2 node configuration
8140 * update ack msg by aper decoder
8142 * @params[in] E2AP_PDU_t *e2apMsg
8143 * @return ROK - success
8146 * ****************************************************************/
8148 void freeAperDecodingOfE2NodeConfigUpdateAck(E2nodeConfigurationUpdateAcknowledge_t *updateAckMsg)
8150 uint8_t arrIdx =0, e2NodeConfigIdx=0;
8151 E2nodeComponentConfigUpdateAck_ItemIEs_t *updateAckItemIe=NULL;
8152 E2nodeComponentConfigUpdateAck_List_t *updateAckList=NULL;
8153 E2nodeComponentConfigRemovalAck_ItemIEs_t *removalAckItemIe=NULL;
8154 E2nodeComponentConfigRemovalAck_List_t *removalAckList=NULL;
8155 E2nodeComponentConfigAdditionAck_ItemIEs_t *additionAckItemIte=NULL;
8156 E2nodeComponentConfigAdditionAck_List_t *additionAckList=NULL;
8158 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULLP;
8159 if(updateAckMsg->protocolIEs.list.array != NULLP)
8161 for(arrIdx = 0; arrIdx < updateAckMsg->protocolIEs.list.count; arrIdx++)
8163 if(updateAckMsg->protocolIEs.list.array[arrIdx])
8165 switch(updateAckMsg->protocolIEs.list.array[arrIdx]->id)
8167 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8169 additionAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8170 if(additionAckList->list.array)
8172 for(e2NodeConfigIdx=0; e2NodeConfigIdx<additionAckList->list.count; e2NodeConfigIdx++)
8174 additionAckItemIte = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) additionAckList->list.array[e2NodeConfigIdx];
8175 if(additionAckItemIte)
8177 switch(additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present)
8179 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8181 f1InterfaceInfo = additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8182 free(f1InterfaceInfo->gNB_DU_ID.buf);
8183 free(f1InterfaceInfo);
8189 free(additionAckItemIte);
8191 free(additionAckList->list.array);
8196 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8198 updateAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8199 if(updateAckList->list.array)
8201 for(e2NodeConfigIdx=0; e2NodeConfigIdx<updateAckList->list.count; e2NodeConfigIdx++)
8203 updateAckItemIe = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) updateAckList->list.array[e2NodeConfigIdx];
8206 switch(updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.present)
8208 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8210 f1InterfaceInfo = updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8211 free(f1InterfaceInfo->gNB_DU_ID.buf);
8212 free(f1InterfaceInfo);
8218 free(updateAckItemIe);
8221 free(updateAckList->list.array);
8225 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8227 removalAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8228 if(removalAckList->list.array)
8230 for(e2NodeConfigIdx=0; e2NodeConfigIdx<removalAckList->list.count; e2NodeConfigIdx++)
8232 removalAckItemIe = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) removalAckList->list.array[e2NodeConfigIdx];
8233 if(removalAckItemIe)
8235 switch(removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.present)
8237 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8239 f1InterfaceInfo = removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8240 free(f1InterfaceInfo->gNB_DU_ID.buf);
8241 free(f1InterfaceInfo);
8247 free(removalAckItemIe);
8250 free(removalAckList->list.array);
8255 free(updateAckMsg->protocolIEs.list.array[arrIdx]);
8258 free(updateAckMsg->protocolIEs.list.array);
8262 /******************************************************************
8264 * @brief Processes the E2 node config update ack msg
8268 * Function :procE2NodeConfigUpdateAck
8270 * Functionality: Processes the E2 node config update ack msg
8272 * @params[in] E2AP_PDU_t ASN decoded E2AP message
8273 * @return ROK - success
8276 * ****************************************************************/
8278 void procE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
8281 uint16_t e2CfgIdx =0;
8282 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck =NULLP;
8283 E2nodeComponentConfigUpdateAck_List_t *e2NodeConfigUpdateAckList=NULLP;
8284 E2nodeComponentConfigUpdateAck_ItemIEs_t *e2NodeUpdateAckItem=NULLP;
8285 E2nodeComponentConfigRemovalAck_List_t *e2NodeConfigRemovalAckList=NULLP;
8286 E2nodeComponentConfigRemovalAck_ItemIEs_t *e2NodeRemovalAckItem=NULLP;
8287 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULLP;
8288 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAdditionAckItem=NULLP;
8290 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
8292 if(e2NodeConfigUpdateAck->protocolIEs.list.array)
8294 for(arrIdx =0; arrIdx<e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
8296 switch(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id)
8298 case ProtocolIE_IDE2_id_TransactionID:
8302 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8304 e2NodeConfigAdditionAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8305 if(e2NodeConfigAdditionAckList->list.array)
8307 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigAdditionAckList->list.count; e2CfgIdx++)
8309 e2NodeAdditionAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2CfgIdx];
8310 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAdditionAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
8311 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
8316 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8318 e2NodeConfigUpdateAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8319 if(e2NodeConfigUpdateAckList->list.array)
8321 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigUpdateAckList->list.count; e2CfgIdx++)
8323 e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[e2CfgIdx];
8324 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeUpdateAckItem->value.choice.E2nodeComponentConfigUpdateAck_Item,\
8325 ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck);
8330 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8332 e2NodeConfigRemovalAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8333 if(e2NodeConfigRemovalAckList->list.array)
8335 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigRemovalAckList->list.count; e2CfgIdx++)
8337 e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[e2CfgIdx];
8338 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeRemovalAckItem->value.choice.E2nodeComponentConfigRemovalAck_Item,\
8339 ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck);
8348 freeAperDecodingOfE2NodeConfigUpdateAck(e2NodeConfigUpdateAck);
8351 /*******************************************************************
8353 * @brief Deallocate the memory allocated for RemovalRequest msg
8357 * Function : FreeRemovalRequest
8360 * - freeing the memory allocated for RemovalRequest
8362 * @params[in] E2AP_PDU_t *e2apMsg
8363 * @return ROK - success
8366 * ****************************************************************/
8367 void FreeRemovalRequest(E2AP_PDU_t *e2apMsg)
8370 E2RemovalRequest_t *removalReq = NULLP;
8372 if(e2apMsg != NULLP)
8374 if(e2apMsg->choice.initiatingMessage != NULLP)
8376 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8377 if(removalReq->protocolIEs.list.array)
8379 for(ieIdx = 0; ieIdx < removalReq->protocolIEs.list.count; ieIdx++)
8381 DU_FREE(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8383 DU_FREE(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8385 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8387 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8391 /*******************************************************************
8393 * @brief Build and send the removal request msg
8397 * Function : BuildAndSendRemovalRequest
8400 * - Buld and send the removal request msg to E2 node
8402 * @return ROK - success
8405 * ****************************************************************/
8407 uint8_t BuildAndSendRemovalRequest()
8409 uint16_t transId = 0;
8410 uint8_t ret = RFAILED;
8411 uint8_t ieIdx = 0, elementCnt = 0;
8412 E2AP_PDU_t *e2apMsg = NULLP;
8413 E2RemovalRequest_t *removalReq = NULLP;
8414 asn_enc_rval_t encRetVal; /* Encoder return value */
8416 DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
8420 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8421 if(e2apMsg == NULLP)
8423 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8427 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
8428 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8429 if(e2apMsg->choice.initiatingMessage == NULLP)
8431 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8435 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2removal;
8436 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
8437 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2RemovalRequest;
8438 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8441 removalReq->protocolIEs.list.count = elementCnt;
8442 removalReq->protocolIEs.list.size = elementCnt * sizeof(E2RemovalRequestIEs_t *);
8444 DU_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8445 if(!removalReq->protocolIEs.list.array)
8447 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8451 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
8453 DU_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8454 if(!removalReq->protocolIEs.list.array[ieIdx])
8456 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8461 /* In case of failure */
8462 if(ieIdx < elementCnt)
8466 removalReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8467 removalReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8468 removalReq->protocolIEs.list.array[ieIdx]->value.present = E2RemovalRequestIEs__value_PR_TransactionID;
8469 transId = assignTransactionId();
8470 removalReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8472 /* Prints the Msg formed */
8473 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8475 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8477 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
8479 if(encRetVal.encoded == ENCODE_FAIL)
8481 DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
8482 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8487 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
8488 #ifdef DEBUG_ASN_PRINT
8489 for(int i=0; i< encBufSize; i++)
8491 printf("%x",encBuf[i]);
8495 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8497 DU_LOG("\nERROR --> E2AP : Sending removal request failed");
8503 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
8504 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
8508 /* Free all memory */
8509 FreeRemovalRequest(e2apMsg);
8514 /******************************************************************
8516 * @brief Deallocation of memory allocated by aper decoder
8517 * for Removal failure
8521 * Function : freeAperDecodingOfE2RemovalFailure
8523 * Functionality: Deallocation of memory allocated by aper decoder
8524 * for Removal failure
8526 * @params[in] Pointer to removalFailure
8529 * ****************************************************************/
8530 void freeAperDecodingOfE2RemovalFailure(E2RemovalFailure_t *removalFailure)
8536 if(removalFailure->protocolIEs.list.array)
8538 for(arrIdx=0; arrIdx<removalFailure->protocolIEs.list.count; arrIdx++)
8540 if(removalFailure->protocolIEs.list.array[arrIdx])
8542 free(removalFailure->protocolIEs.list.array[arrIdx]);
8545 free(removalFailure->protocolIEs.list.array);
8550 /******************************************************************
8552 * @brief Processes the E2 removal failure msg
8556 * Function : procE2RemovalFailure
8558 * Functionality: Processes the E2 removal failure msg
8561 * E2AP_PDU_t *e2apMsg
8565 * ****************************************************************/
8566 void ProcE2RemovalFailure(E2AP_PDU_t *e2apMsg)
8570 CauseE2_t *cause = NULLP;
8571 E2RemovalFailure_t *e2RemovalFailure=NULLP;
8573 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
8575 if(!e2RemovalFailure->protocolIEs.list.array)
8577 DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
8581 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
8583 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
8585 switch(e2RemovalFailure->protocolIEs.list.array[ieIdx]->id)
8587 case ProtocolIE_IDE2_id_TransactionID:
8589 transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8590 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8591 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8593 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8597 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8601 case ProtocolIE_IDE2_id_CauseE2:
8603 cause = &e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
8604 printE2ErrorCause(cause);
8609 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
8615 freeAperDecodingOfE2RemovalFailure(e2RemovalFailure);
8618 /******************************************************************
8620 * @brief Deallocation of memory allocated by aper decoder
8621 * for Removal failure
8625 * Function : freeAperDecodingOfE2RemovalResponse
8627 * Functionality: Deallocation of memory allocated by aper decoder
8628 * for Removal failure
8630 * @params[in] Pointer to removalResponse
8633 * ****************************************************************/
8634 void freeAperDecodingOfE2RemovalResponse(E2RemovalResponse_t *removalResponse)
8640 if(removalResponse->protocolIEs.list.array)
8642 for(arrIdx=0; arrIdx<removalResponse->protocolIEs.list.count; arrIdx++)
8644 if(removalResponse->protocolIEs.list.array[arrIdx])
8646 free(removalResponse->protocolIEs.list.array[arrIdx]);
8649 free(removalResponse->protocolIEs.list.array);
8654 /*******************************************************************
8656 * @brief process the E2 Removal Response
8660 * Function : ProcE2RemovalResponse
8662 * Functionality: Process E2 Removal Response
8665 * E2AP_PDU_t *e2apMsg
8668 ******************************************************************/
8670 void ProcE2RemovalResponse(E2AP_PDU_t *e2apMsg)
8674 E2RemovalResponse_t *removalRsp = NULLP;
8676 removalRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
8678 if(!removalRsp->protocolIEs.list.array)
8680 DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
8684 for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
8686 if(removalRsp->protocolIEs.list.array[ieIdx])
8688 switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
8690 case ProtocolIE_IDE2_id_TransactionID:
8692 transId = removalRsp->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8693 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8694 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8696 DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
8697 cmInetClose(&ricParams.sockFd);
8698 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8699 removeE2NodeInformation();
8703 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8709 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
8716 freeAperDecodingOfE2RemovalResponse(removalRsp);
8719 /*******************************************************************
8721 * @brief Deallocate the memory allocated for E2 Connection Update Failure
8725 * Function : FreeE2ConnectionUpdateFailure
8728 * - freeing the memory allocated for E2ConnectionUpdateFailure
8730 * @params[in] E2AP_PDU_t *e2apMsg
8731 * @return ROK - success
8734 * ****************************************************************/
8735 void FreeE2ConnectionUpdateFailure(E2AP_PDU_t *e2apMsg)
8738 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8740 if(e2apMsg != NULLP)
8742 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
8744 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8745 if(e2ConnectionUpdateFailure->protocolIEs.list.array)
8747 for(ieIdx=0; ieIdx < e2ConnectionUpdateFailure->protocolIEs.list.count; ieIdx++)
8749 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8751 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8753 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8755 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8759 /*******************************************************************
8761 * @brief Buld and send the E2 Connection Update Failure msg
8765 * Function : BuildAndSendE2ConnectionUpdateFailure
8768 * - Buld and send the E2 Connection Update Failure Message
8772 * @return ROK - success
8775 * ****************************************************************/
8777 uint8_t BuildAndSendE2ConnectionUpdateFailure(uint16_t transId, E2FailureCause failureCause)
8779 uint8_t ieIdx = 0, elementCnt = 0;
8780 uint8_t ret = RFAILED;
8781 E2AP_PDU_t *e2apMsg = NULLP;
8782 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8783 asn_enc_rval_t encRetVal; /* Encoder return value */
8785 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Failure Message\n");
8788 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8789 if(e2apMsg == NULLP)
8791 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8794 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
8796 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8797 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
8799 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8803 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
8804 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
8805 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure;
8806 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8809 e2ConnectionUpdateFailure->protocolIEs.list.count = elementCnt;
8810 e2ConnectionUpdateFailure->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateFailure_IEs_t *);
8811 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8812 if(!e2ConnectionUpdateFailure->protocolIEs.list.array)
8814 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8818 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
8820 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8821 if(!e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx])
8823 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8827 if(ieIdx < elementCnt)
8831 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8832 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8833 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_TransactionID;
8834 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8838 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
8839 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
8840 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_CauseE2;
8841 fillE2Cause(&e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, failureCause);
8843 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8845 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8847 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
8848 if(encRetVal.encoded == ENCODE_FAIL)
8850 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update failure structure (at %s)\n",\
8851 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8856 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Failure \n");
8857 for(int i=0; i< encBufSize; i++)
8859 DU_LOG("%x",encBuf[i]);
8864 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8866 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Failure");
8874 FreeE2ConnectionUpdateFailure(e2apMsg);
8878 /*******************************************************************
8880 * @brief fill E2 connection update item
8884 * Function : fillE2connectionUpdateItem
8886 * Functionality: fill E2 connection update item
8889 * E2connectionUpdate Item to be filled
8893 * @return ROK - success
8895 * ****************************************************************/
8897 uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId, uint32_t ipAddress, AssocUsage usage)
8899 CauseE2_t *cause=NULLP;
8900 TNLusage_t *tnlUsage=NULLP;
8901 E2FailureCause failureCause;
8902 TNLinformation_t *tnlInformation = NULLP;
8903 E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
8904 E2connectionSetupFailed_Item_t *connectionRemoveITem=NULLP;
8908 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8910 connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
8911 tnlInformation = &connectionModifyItem->tnlInformation;
8912 tnlUsage = &connectionModifyItem->tnlUsage;
8916 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8918 connectionRemoveITem = (E2connectionSetupFailed_Item_t*)connectionInfo;
8919 tnlInformation= &connectionRemoveITem->tnlInformation;
8920 cause = &connectionRemoveITem->cause;
8927 tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
8928 DU_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
8929 if(!tnlInformation->tnlAddress.buf)
8931 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8935 tnlInformation->tnlAddress.buf[3] = ipAddress & 0xFF;
8936 tnlInformation->tnlAddress.buf[2] = (ipAddress>> 8) & 0xFF;
8937 tnlInformation->tnlAddress.buf[1] = (ipAddress>> 16) & 0xFF;
8938 tnlInformation->tnlAddress.buf[0] = (ipAddress>> 24) & 0xFF;
8939 tnlInformation->tnlAddress.bits_unused = 0;
8943 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8948 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8950 failureCause.causeType = E2_TRANSPORT;
8951 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
8952 fillE2Cause(cause, failureCause);
8962 /*******************************************************************
8964 * @brief Build E2 connection modification list
8968 * Function :BuildE2ConnectionUpdateList
8970 * Functionality: Build E2 connection modification list
8973 * E2 connection update list to be filled
8974 * Count of E2 connection to be added in the list
8975 * Received list of E2 connection
8977 * @return ROK - success
8979 * ****************************************************************/
8981 uint8_t BuildE2ConnectionUpdateList(E2connectionUpdate_List_t *connectionSetupList, uint8_t count, E2ConnectionItem *tmpConnectionList)
8984 E2connectionUpdate_ItemIEs_t *connectionSetupItem=NULLP;
8986 connectionSetupList->list.count = count;
8988 connectionSetupList->list.size = connectionSetupList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
8989 DU_ALLOC(connectionSetupList->list.array, connectionSetupList->list.size);
8990 if(connectionSetupList->list.array)
8992 for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
8994 DU_ALLOC(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
8995 if(connectionSetupList->list.array[arrIdx] == NULLP)
8997 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9000 connectionSetupItem = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
9001 connectionSetupItem->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
9002 connectionSetupItem->criticality= CriticalityE2_ignore;
9003 connectionSetupItem->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
9004 if(fillE2connectionUpdateItem((PTR)&connectionSetupItem->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item,\
9005 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
9007 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
9015 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9021 /*******************************************************************
9023 * @brief Build E2 connection setup failed list
9027 * Function : BuildE2ConnectionSetupFailedList
9029 * Functionality: Build E2 connection setup failed list
9032 * E2 connection setup failed list to be filled
9033 * Count of E2 connection to be added in the list
9034 * Received list of E2 connection
9036 * @return ROK - success
9038 * ****************************************************************/
9040 uint8_t BuildE2ConnectionSetupFailedList(E2connectionSetupFailed_List_t *setupFailedList, uint8_t count, E2ConnectionItem *tmpConnectionList)
9043 E2connectionSetupFailed_ItemIEs_t *setupFailedItem=NULLP;
9045 setupFailedList->list.count = 1;
9047 setupFailedList->list.size = setupFailedList->list.count*sizeof(E2connectionSetupFailed_ItemIEs_t *);
9048 DU_ALLOC(setupFailedList->list.array, setupFailedList->list.size);
9049 if(setupFailedList->list.array)
9051 for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
9053 DU_ALLOC(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9054 if(setupFailedList->list.array[arrIdx] == NULLP)
9056 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9059 setupFailedItem = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
9060 setupFailedItem->id = ProtocolIE_IDE2_id_E2connectionSetupFailed_Item;
9061 setupFailedItem->criticality= CriticalityE2_ignore;
9062 setupFailedItem->value.present = E2connectionSetupFailed_ItemIEs__value_PR_E2connectionSetupFailed_Item;
9063 if(fillE2connectionUpdateItem((PTR)&setupFailedItem->value.choice.E2connectionSetupFailed_Item, ProtocolIE_IDE2_id_E2connectionSetupFailed_Item,\
9064 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
9066 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection failed to update item");
9074 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9080 /*******************************************************************
9082 * @brief Deallocate the memory allocated for E2 Connection
9087 * Function :FreeE2ConnectionUpdateAcknowledge
9090 * - freeing the memory allocated for E2 Connection
9093 * @params[in] E2AP_PDU_t *e2apMsg
9094 * @return ROK - success
9097 * ****************************************************************/
9099 void FreeE2ConnectionUpdateAcknowledge(E2AP_PDU_t *e2apMsg)
9101 uint8_t ieIdx =0, arrIdx=0;
9102 E2connectionUpdateAcknowledge_t *connectionUpdate = NULLP;
9103 E2connectionUpdate_List_t *connectionSetupList = NULLP;
9104 E2connectionSetupFailed_List_t *setupFailedList = NULLP;
9106 if(e2apMsg != NULLP)
9108 if(e2apMsg->choice.successfulOutcome != NULLP)
9110 connectionUpdate = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9111 if(connectionUpdate->protocolIEs.list.array)
9113 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9115 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9117 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9119 case ProtocolIE_IDE2_id_TransactionID:
9122 case ProtocolIE_IDE2_id_E2connectionSetup:
9124 connectionSetupList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9125 if(connectionSetupList->list.array)
9127 for(arrIdx = 0; arrIdx < connectionSetupList->list.count; arrIdx++)
9129 DU_FREE(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
9131 DU_FREE(connectionSetupList->list.array, connectionSetupList->list.size);
9136 case ProtocolIE_IDE2_id_E2connectionSetupFailed:
9138 setupFailedList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
9139 if(setupFailedList->list.array)
9141 for(arrIdx = 0; arrIdx < setupFailedList->list.count; arrIdx++)
9143 DU_FREE(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9145 DU_FREE(setupFailedList->list.array, setupFailedList->list.size);
9150 DU_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9153 DU_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
9155 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9157 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
9161 /*******************************************************************
9163 * @brief Buld and send the E2 Connection Update Acknowledge msg
9167 * Function : BuildAndSendE2ConnectionUpdateAcknowledge
9170 * - Buld and send the E2 Connection Update Acknowledge Message
9173 * List of E2 connection needs to fill in IE
9174 * @return ROK - success
9177 * ****************************************************************/
9179 uint8_t BuildAndSendE2ConnectionUpdateAcknowledge(uint16_t transId, E2ConnectionList connectionInfoList)
9181 uint8_t ieIdx = 0, elementCnt = 0;
9182 uint8_t ret = RFAILED;
9183 E2AP_PDU_t *e2apMsg = NULLP;
9184 asn_enc_rval_t encRetVal;
9185 E2connectionUpdateAcknowledge_t *e2ConnectionUpdateAcknowledge=NULLP;
9187 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Acknowledge Message\n");
9190 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
9191 if(e2apMsg == NULLP)
9193 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9196 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
9198 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9199 if(e2apMsg->choice.successfulOutcome == NULLP)
9201 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9205 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
9206 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
9207 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge;
9208 e2ConnectionUpdateAcknowledge = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9211 if(connectionInfoList.numOfE2ConnectionSetup)
9213 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9216 e2ConnectionUpdateAcknowledge->protocolIEs.list.count = elementCnt;
9217 e2ConnectionUpdateAcknowledge->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateAck_IEs_t*);
9218 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array, e2ConnectionUpdateAcknowledge->protocolIEs.list.size);
9219 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array)
9221 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9225 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
9227 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9228 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx])
9230 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9234 if(ieIdx < elementCnt)
9238 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
9239 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9240 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_TransactionID;
9241 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
9243 if(connectionInfoList.numOfE2ConnectionSetup)
9246 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetup;
9247 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9248 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionUpdate_List;
9249 if(BuildE2ConnectionUpdateList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List, \
9250 connectionInfoList.numOfE2ConnectionSetup, connectionInfoList.setupE2Connection) != ROK)
9252 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection setup list");
9257 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9260 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetupFailed;
9261 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9262 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionSetupFailed_List;
9263 if(BuildE2ConnectionSetupFailedList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List, \
9264 connectionInfoList.numOfE2ConnectionFailedToSetup, connectionInfoList.failedToSetupE2Connection) != ROK)
9266 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection failed to setup list");
9271 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
9273 memset(encBuf, 0, ENC_BUF_MAX_LEN);
9275 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
9276 if(encRetVal.encoded == ENCODE_FAIL)
9278 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update acknowledge failure structure (at %s)\n",\
9279 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9284 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Acknowledge \n");
9285 for(int i=0; i< encBufSize; i++)
9287 DU_LOG("%x",encBuf[i]);
9292 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
9294 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Acknowledge");
9302 FreeE2ConnectionUpdateAcknowledge(e2apMsg);
9306 /******************************************************************
9308 * @brief Deallocation of memory allocated by aper decoder for
9309 * E2 Connection Update
9313 * Function :freeAperDecodingOfE2ConnectionUpdate
9315 * Functionality: Deallocation of memory allocated by aper decoder for
9316 * E2 Connection Update
9318 * @params[in] Pointer to connectionUpdate
9321 * ****************************************************************/
9323 void freeAperDecodingOfE2ConnectionUpdate(E2connectionUpdate_t *connectionUpdate)
9325 uint8_t ieIdx =0, arrIdx=0;
9326 E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
9327 E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
9329 if(connectionUpdate->protocolIEs.list.array)
9331 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9333 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9335 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9337 case ProtocolIE_IDE2_id_TransactionID:
9340 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9342 connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9343 if(connectionToBeModifyList->list.array)
9345 for(arrIdx= 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
9347 free(connectionToBeModifyList->list.array[arrIdx]);
9349 free(connectionToBeModifyList->list.array);
9353 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9355 connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
9356 if(connectionToBeRemoveList->list.array)
9358 for(arrIdx= 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
9360 free(connectionToBeRemoveList->list.array[arrIdx]);
9362 free(connectionToBeRemoveList->list.array);
9367 free(connectionUpdate->protocolIEs.list.array[ieIdx]);
9370 free(connectionUpdate->protocolIEs.list.array);
9374 /*******************************************************************
9376 * @brief Handling of E2 connection modification Ie
9380 * Function : handleE2ConnectionModification
9382 * Functionality: Handling of E2 connection modification Ie
9385 * E2 Connection update list
9386 * E2 connection list which needs to be filled
9389 ******************************************************************/
9391 void handleE2ConnectionModification(E2connectionUpdate_List_t *connectionUpdateList, E2ConnectionList *connectionInfoList)
9393 uint32_t ipAddress=0;
9394 bool infoFound = false;
9395 uint8_t arrIdx=0,idx=0, count =0;
9396 E2connectionUpdate_ItemIEs_t *connectionModifyItem=NULLP;
9398 if(connectionUpdateList->list.array)
9400 for(arrIdx = 0; arrIdx < connectionUpdateList->list.count; arrIdx++)
9402 connectionModifyItem= (E2connectionUpdate_ItemIEs_t*)connectionUpdateList->list.array[arrIdx];
9403 bitStringToInt(&connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlInformation.tnlAddress, &ipAddress);
9404 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9406 /* If the TNL information is found in the data base, update the
9407 * information in the database */
9408 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9410 duCb.e2apDb.tnlAssoc[idx].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9416 /* If the TNL information is found in the data base, then add the
9417 * information in setupE2Connection array else add in failedToSetupE2Connection array */
9418 if(infoFound == true)
9420 count =connectionInfoList->numOfE2ConnectionSetup;
9421 connectionInfoList->setupE2Connection[count].ipV4Addr = duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr;
9422 connectionInfoList->setupE2Connection[count].usage = duCb.e2apDb.tnlAssoc[idx].usage;
9423 connectionInfoList->numOfE2ConnectionSetup++;
9427 count = connectionInfoList->numOfE2ConnectionFailedToSetup;
9428 connectionInfoList->failedToSetupE2Connection[count].ipV4Addr = ipAddress;
9429 connectionInfoList->failedToSetupE2Connection[count].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9430 connectionInfoList->numOfE2ConnectionFailedToSetup++;
9437 /*******************************************************************
9439 * @brief Handling of E2 connection removal Ie
9443 * Function : handleE2ConnectionRemoval
9445 * Functionality: Handling of E2 connection removal Ie
9448 * E2 Connection removal List
9451 ******************************************************************/
9453 void handleE2ConnectionRemoval(E2connectionUpdateRemove_List_t *connectionRemovalList)
9455 uint32_t ipAddress=0;
9456 uint8_t arrIdx=0,idx=0;
9457 E2connectionUpdateRemove_ItemIEs_t *connectionRemovalItem=NULLP;
9459 if(connectionRemovalList->list.array)
9461 for(arrIdx = 0; arrIdx < connectionRemovalList->list.count; arrIdx++)
9463 connectionRemovalItem= (E2connectionUpdateRemove_ItemIEs_t*)connectionRemovalList->list.array[arrIdx];
9464 bitStringToInt(&connectionRemovalItem->value.choice.E2connectionUpdateRemove_Item.tnlInformation.tnlAddress, &ipAddress);
9465 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9467 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9469 cmInetClose(&ricParams.sockFd);
9470 removeE2NodeInformation();
9479 /*******************************************************************
9481 * @brief Process e2 connection update received from RIC
9485 * Function : procE2ConnectionUpdate
9487 * Functionality: Process e2 connection update received from RIC
9489 * @param E2AP_PDU_t *e2apMsg
9492 ******************************************************************/
9494 void procE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
9497 uint16_t transId =0;
9498 bool invalidTransId = false, connectionFailedToUpdate=false;
9499 E2FailureCause failureCause;
9500 E2ConnectionList connectionInfoList;
9501 E2connectionUpdate_t *connectionUpdate=NULLP;
9503 DU_LOG("\nINFO --> E2AP : E2 connection update received");
9504 connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
9506 memset(&connectionInfoList, 0, sizeof(E2ConnectionList));
9507 for(arrIdx=0; arrIdx<connectionUpdate->protocolIEs.list.count; arrIdx++)
9509 switch(connectionUpdate->protocolIEs.list.array[arrIdx]->id)
9511 case ProtocolIE_IDE2_id_TransactionID:
9513 transId = connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
9516 failureCause.causeType = E2_PROTOCOL;
9517 failureCause.cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
9518 invalidTransId = true;
9523 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9525 handleE2ConnectionModification(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdate_List,\
9526 &connectionInfoList);
9527 if((connectionInfoList.numOfE2ConnectionSetup == 0) && (connectionInfoList.numOfE2ConnectionFailedToSetup > 0))
9529 failureCause.causeType = E2_TRANSPORT;
9530 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
9531 connectionFailedToUpdate =true;
9537 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9539 handleE2ConnectionRemoval(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdateRemove_List);
9545 DU_LOG("\nERROR --> E2AP : Invalid IE received[%ld]",connectionUpdate->protocolIEs.list.array[arrIdx]->id);
9550 if(invalidTransId == true || connectionFailedToUpdate ==true)
9554 if(invalidTransId == true || connectionFailedToUpdate == true)
9556 if(BuildAndSendE2ConnectionUpdateFailure(transId, failureCause) != ROK)
9558 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update failure");
9563 if(BuildAndSendE2ConnectionUpdateAcknowledge(transId, connectionInfoList) != ROK)
9565 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update ack");
9569 freeAperDecodingOfE2ConnectionUpdate(connectionUpdate);
9572 /*******************************************************************
9574 * @brief Free RIC Subscription action to be added list
9578 * Function : freeAperDecodingOfRicSubsActionToBeAdded
9580 * Functionality: Free the RIC Subscription action to be added list
9582 * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
9585 * ****************************************************************/
9586 void freeAperDecodingOfRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
9588 uint8_t elementIdx = 0;
9589 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
9591 if(subsDetails->list.array)
9593 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9595 if(subsDetails->list.array[elementIdx])
9597 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
9598 free(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf);
9599 free(subsDetails->list.array[elementIdx]);
9602 free(subsDetails->list.array);
9606 /*******************************************************************
9608 * @brief Deallocation of memory allocated by aper decoder for
9609 * RIC Subscription action to be removed list
9613 * Function : freeAperDecodingOfRicSubsActionToBeRemoved
9615 * Functionality: Free the RIC Subscription action to be removed list
9617 * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
9620 * ****************************************************************/
9621 void freeAperDecodingOfRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
9623 uint8_t elementIdx = 0;
9625 if(subsDetails->list.array)
9627 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9629 if(subsDetails->list.array[elementIdx])
9631 free(subsDetails->list.array[elementIdx]);
9634 free(subsDetails->list.array);
9638 /*******************************************************************
9640 * @brief Deallocation of memory allocated by aper decoder for
9641 * RIC Subscription action to be modify
9645 * Function : freeAperDecodingOfRicSubsActionToBeModified
9647 * Functionality: Free the RIC Subscription action to be modify
9649 * @params[in] RICactions_ToBeModifiedForModification_List_t List
9652 * ****************************************************************/
9653 void freeAperDecodingOfRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
9655 uint8_t elementIdx = 0;
9656 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
9658 if(subsDetails->list.array)
9660 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9662 if(subsDetails->list.array[elementIdx])
9664 actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx];
9665 if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
9667 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf);
9668 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition);
9670 free(subsDetails->list.array[elementIdx]);
9673 free(subsDetails->list.array);
9677 /*******************************************************************
9679 * @brief Deallocation of memory allocated by aper decoder for
9680 * RIC Subscription modification Request
9684 * Function freeAperDecodingOfRicSubsModificationReq
9686 * Functionality : Free RIC Subscription modification Request
9688 * @params[in] E2AP_PDU
9691 ******************************************************************/
9692 void freeAperDecodingOfRicSubsModificationReq(E2AP_PDU_t *e2apRicMsg)
9695 RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
9696 RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe;
9698 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
9700 if(ricSubscriptionModReq->protocolIEs.list.array)
9702 for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
9704 if(ricSubscriptionModReq->protocolIEs.list.array[idx])
9706 ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
9708 switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
9710 case ProtocolIE_IDE2_id_RICrequestID:
9713 case ProtocolIE_IDE2_id_RANfunctionID:
9716 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
9718 freeAperDecodingOfRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
9721 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
9723 freeAperDecodingOfRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
9726 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
9728 freeAperDecodingOfRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
9733 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
9739 free(ricSubscriptionModReq->protocolIEs.list.array[idx]);
9742 free(ricSubscriptionModReq->protocolIEs.list.array);
9745 /*******************************************************************
9747 * @brief Extract RIC Action to be added
9751 * Function : extractRicActionToBeAddedForModification
9753 * Functionality : This function :
9754 * - [Step -1] Traverse each AddedForModification item indexes.
9755 * - [Step -2] Add each action id related information in
9756 * RicSubscription Db.
9757 * - [Step -3] If failed to store then add action related info in
9758 * pending rsp's rejectedActionList.
9759 * - [Step -4] Else increment action added count
9760 * - [Step -5] If there is even 1 action that can be added,
9761 * return ROK, else RFAILED.
9763 * @params[in] RAN Function Database structure
9764 * RIC Subscription Info to be added to RAN function
9765 * RIC Action To Be AddedForModification List received from RIC
9767 * Pending Subs Mod Rsp Info
9768 * @return ROK - success
9771 ******************************************************************/
9772 uint8_t extractRicActionToBeAddedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9773 RICactions_ToBeAddedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9775 uint8_t actionAdded=0;
9776 CmLList *actionNode = NULLP;
9777 uint8_t actionIdx = 0;
9778 uint8_t ricActionId = 0;
9779 RICaction_ToBeAddedForModification_ItemIEs_t *actionItem = NULLP;
9781 if(actionList->list.array)
9783 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9786 actionItem =(RICaction_ToBeAddedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9787 switch(actionItem->id)
9789 case ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item:
9792 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeAddedForModification_Item,\
9793 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item, failureCause);
9798 subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].id = ricActionId;
9799 if(failureCause->causeType == E2_NOTHING)
9801 failureCause->causeType = E2_RIC_REQUEST;
9802 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
9804 memcpy(&subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].failureCause, \
9805 failureCause, sizeof(E2FailureCause));
9806 subsModRsp->addActionStatus.numOfRejectedActions++;
9816 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicAddedForModificationLst:%ld",actionItem->id);
9826 if(failureCause->causeType == E2_NOTHING)
9828 failureCause->causeType = E2_RIC_REQUEST;
9829 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
9834 /*******************************************************************
9836 * @brief Extract RIC Action to be Modified
9840 * Function : extractRicActionToBeModifiedForModification
9842 * Functionality : This function :
9843 * - [Step -1] Traverse each Modification item indexes.
9844 * - [Step -2] Find each action id related information in
9845 * RicSubscription Db.
9846 * - [Step -3] If not found store the action related info in pending
9847 * rsp's action rejected.
9848 * - [Step -4] If found store the new node in action seq list.
9849 * [Step -4.1] If action failed to store, add the action
9850 * info in pending subscription rsp's rejected list.
9851 * [Step -4.2] If action stored successfully, change the status
9852 * of added action to modified because action added as part of
9853 * ric subscription modification req.
9854 * - [Step -5] If there is even 1 action that can be modified,
9855 * return ROK, else RFAILED.
9857 * @params[in] RAN Function Database structure
9858 * RIC Subscription Info to be Modified to RAN function
9859 * RIC Action To Be ModifiedForModification List received from RIC
9861 * Pending Subs Mod Rsp Info
9862 * @return ROK - success
9865 ******************************************************************/
9866 uint8_t extractRicActionToBeModifiedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9867 RICactions_ToBeModifiedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9870 uint8_t actionIdx = 0;
9871 uint8_t actionFound=0;
9872 CmLList *actionNode = NULLP;
9873 ActionInfo *actionDb = NULLP;
9874 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
9876 if(actionList->list.array)
9878 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9881 actionItem =(RICaction_ToBeModifiedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9882 switch(actionItem->id)
9884 case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item:
9887 actionId=actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID;
9888 actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
9892 subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionDb->actionId;
9893 failureCause->causeType = E2_RIC_REQUEST;
9894 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
9895 memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \
9896 failureCause, sizeof(E2FailureCause));
9897 subsModRsp->modActionStatus.numOfRejectedActions++;
9903 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeModifiedForModification_Item,\
9904 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item, failureCause);
9909 subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionId;
9910 if(failureCause->causeType == E2_NOTHING)
9912 failureCause->causeType = E2_RIC_REQUEST;
9913 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
9915 memcpy(&subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \
9916 failureCause, sizeof(E2FailureCause));
9917 subsModRsp->addActionStatus.numOfRejectedActions++;
9922 actionDb = (ActionInfo*)actionNode->node;
9923 actionDb->action=CONFIG_MOD;
9931 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicModifiedForModificationLst:%ld",actionItem->id);
9944 /*******************************************************************
9946 * @brief Extract RIC Action to be Removed
9950 * Function : extractRicActionToBeRemovedForModification
9952 * Functionality : This function :
9953 * - [Step -1] Traverse each RemovedForModification item indexes.
9954 * - [Step -2] Find each action id related information in
9955 * RicSubscription Db.
9956 * - [Step -3] If not found store the action related info in pending
9957 * rsp's rejectedActionList.
9958 * - [Step -4] If found mark action's status CONFIG_DEL.
9959 * - [Step -5] If there is even 1 action that can be Removed,
9960 * return ROK, else RFAILED.
9962 * @params[in] RAN Function Database structure
9963 * RIC Subscription Info to be Removed to RAN function
9964 * RIC Action To Be RemovedForModification List received from RIC
9966 * Pending ric subs mod Rsp Info to store failure result
9967 * @return ROK - success
9970 ******************************************************************/
9971 uint8_t extractRicActionToBeRemovedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9972 RICactions_ToBeRemovedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9975 uint8_t actionIdx = 0;
9976 uint8_t actionFound=0;
9977 CmLList *actionNode = NULLP;
9978 ActionInfo *actionDb = NULLP;
9979 RICaction_ToBeRemovedForModification_ItemIEs_t *actionItem = NULLP;
9981 if(actionList->list.array)
9983 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9986 actionItem =(RICaction_ToBeRemovedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9987 switch(actionItem->id)
9989 case ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item:
9992 actionId = actionItem->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID;
9993 actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
9997 subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].id = actionDb->actionId;
9998 if(failureCause->causeType == E2_NOTHING)
10000 failureCause->causeType = E2_RIC_REQUEST;
10001 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
10003 memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].failureCause, \
10004 failureCause, sizeof(E2FailureCause));
10005 subsModRsp->removeActionStatus.numOfRejectedActions++;
10010 actionDb->action=CONFIG_DEL;
10016 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicRemovedForModificationLst:%ld",actionItem->id);
10029 /*******************************************************************
10031 * @brief Process RIC Subscription modification request
10035 * Function : procRicSubscriptionModificationRequest
10037 * Functionality: Process RIC subscription modification request.
10039 * @params[in] E2AP PDU
10042 ******************************************************************/
10043 void procRicSubscriptionModificationRequest(E2AP_PDU_t *e2apMsg)
10046 uint16_t ranFuncId = 0;
10047 RicRequestId ricReqId;
10048 E2FailureCause failureCause;
10049 bool procFailure = false;
10050 bool addActionIeProcessed=false;
10051 bool modActionIeProcessed =false;
10052 bool removeActionIeProcessed =false;
10053 CmLList *ricSubsNode = NULLP;
10054 RanFunction *ranFuncDb = NULLP;
10055 RicSubscription *ricSubsDb = NULLP;
10056 RICsubscriptionModificationRequest_t *ricSubsModifyReq = NULLP;
10057 RICsubscriptionModificationRequest_IEs_t *ricSubsModifyReqIe = NULLP;
10059 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Request", __func__);
10064 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
10068 if(!e2apMsg->choice.initiatingMessage)
10070 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
10074 ricSubsModifyReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
10075 for(ieIdx = 0; ieIdx < ricSubsModifyReq->protocolIEs.list.count; ieIdx++)
10077 if(!ricSubsModifyReq->protocolIEs.list.array[ieIdx])
10079 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
10083 ricSubsModifyReqIe = ricSubsModifyReq->protocolIEs.list.array[ieIdx];
10084 switch(ricSubsModifyReqIe->id)
10086 case ProtocolIE_IDE2_id_RICrequestID:
10088 memset(&ricReqId, 0, sizeof(RicRequestId));
10089 ricReqId.requestorId = ricSubsModifyReqIe->value.choice.RICrequestID.ricRequestorID;
10090 ricReqId.instanceId = ricSubsModifyReqIe->value.choice.RICrequestID.ricInstanceID;
10094 case ProtocolIE_IDE2_id_RANfunctionID:
10096 ranFuncId = ricSubsModifyReqIe->value.choice.RANfunctionID;
10097 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
10100 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
10101 procFailure = true;
10105 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
10108 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
10109 __func__, ricReqId.requestorId, ricReqId.instanceId);
10110 procFailure = true;
10113 memset(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp], 0, sizeof(PendingSubsModRspInfo));
10114 memcpy(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].requestId,
10115 &ricReqId, sizeof(RicRequestId));
10116 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].ranFuncId = ranFuncId;
10120 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
10122 if(extractRicActionToBeRemovedForModification(ranFuncDb, ricSubsDb,\
10123 &ricSubsModifyReqIe->value.choice.RICactions_ToBeRemovedForModification_List,\
10124 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10126 removeActionIeProcessed= true;
10131 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
10133 if(extractRicActionToBeModifiedForModification(ranFuncDb, ricSubsDb,\
10134 &ricSubsModifyReqIe->value.choice.RICactions_ToBeModifiedForModification_List,\
10135 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10137 modActionIeProcessed = true;
10141 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
10143 if(extractRicActionToBeAddedForModification(ranFuncDb, ricSubsDb,\
10144 &ricSubsModifyReqIe->value.choice.RICactions_ToBeAddedForModification_List,\
10145 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10147 addActionIeProcessed = true;
10153 } /* End of switch for Protocol IE Id */
10157 } /* End of for loop for Protocol IE list */
10162 if(!removeActionIeProcessed && !addActionIeProcessed && !modActionIeProcessed)
10164 BuildAndSendRicSubscriptionModificationFailure(ranFuncId, ricReqId, failureCause);
10168 if(duChkTmr((PTR)ricSubsDb, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR) == true)
10170 duStopTmr((PTR)ricSubsDb, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR);
10173 ricSubsDb->action = CONFIG_MOD;
10174 ranFuncDb->numPendingSubsModRsp++;
10176 /*If the remove-action ie is present, send a stats delete request;
10177 * otherwise, change removeActionCompleted to true in the pendingSubsModRspInfo. */
10178 if(removeActionIeProcessed)
10180 BuildAndSendStatsDeleteReq(ricSubsDb, false);
10184 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].removeActionCompleted = true;
10187 /*If the mod-action ie is present, send a stats modification request;
10188 * otherwise, change modActionCompleted to true in the pendingSubsModRspInfo. */
10189 if(modActionIeProcessed)
10191 BuildAndSendStatsModificationReq(ricSubsDb);
10195 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].modActionCompleted= true;
10198 /*If the add-action ie is present, send a stats add request;
10199 * otherwise, change addActionCompleted to true in the pendingSubsModRspInfo. */
10200 if(addActionIeProcessed)
10202 BuildAndSendStatsReq(ricSubsDb);
10206 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].addActionCompleted= true;
10211 freeAperDecodingOfRicSubsModificationReq(e2apMsg);
10214 /*******************************************************************
10215 * @brief Free RIC Subscription Modification Failure Message
10219 * Function : FreeRicSubscriptionModificationFailure
10221 * Functionality: Free RIC Subscription Modification Failure
10223 * @param E2AP Message PDU
10226 ******************************************************************/
10227 void FreeRicSubscriptionModificationFailure(E2AP_PDU_t *e2apMsg)
10230 RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
10234 if(e2apMsg->choice.unsuccessfulOutcome)
10236 ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
10237 if(ricSubsModFailure->protocolIEs.list.array)
10239 for(ieIdx = 0; ieIdx < ricSubsModFailure->protocolIEs.list.count; ieIdx++)
10241 DU_FREE(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
10243 DU_FREE(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
10245 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
10247 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
10250 /*******************************************************************
10252 * @brief Builds and Send RIC Subscription Modification Failure
10256 * Function : BuildAndSendRicSubscriptionModificationFailure
10258 * Functionality: Build and send RIC Subscription Modification Failure.
10264 * @return ROK - success
10265 * RFAILED - failure
10267 ******************************************************************/
10268 uint8_t BuildAndSendRicSubscriptionModificationFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
10270 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
10271 E2AP_PDU_t *e2apMsg = NULLP;
10272 RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
10273 RICsubscriptionModificationFailure_IEs_t *ricSubsModFailureIe = NULLP;
10274 asn_enc_rval_t encRetVal; /* Encoder return value */
10278 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Failure Message\n");
10280 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
10281 if(e2apMsg == NULLP)
10283 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10287 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
10288 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
10289 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
10291 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10294 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
10295 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
10296 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure;
10299 ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
10302 ricSubsModFailure->protocolIEs.list.count = elementCnt;
10303 ricSubsModFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationFailure_IEs_t *);
10305 DU_ALLOC(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
10306 if(ricSubsModFailure->protocolIEs.list.array == NULLP)
10308 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
10312 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
10314 DU_ALLOC(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
10315 if(ricSubsModFailure->protocolIEs.list.array[ieIdx] == NULLP)
10317 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
10318 __func__, ieIdx, __LINE__);
10322 if(ieIdx < elementCnt)
10326 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10327 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
10328 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10329 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RICrequestID;
10330 ricSubsModFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
10331 ricSubsModFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
10334 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10335 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
10336 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10337 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RANfunctionID;
10338 ricSubsModFailureIe->value.choice.RANfunctionID = ranFuncId;
10341 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10342 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
10343 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10344 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_CauseE2;
10345 fillE2Cause(&ricSubsModFailureIe->value.choice.CauseE2, failureCause);
10347 /* Prints the Msg formed */
10348 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
10349 memset(encBuf, 0, ENC_BUF_MAX_LEN);
10351 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
10352 if(encRetVal.encoded == ENCODE_FAIL)
10354 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Failure Message (at %s)\n",\
10355 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10360 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Failure Message \n");
10361 #ifdef DEBUG_ASN_PRINT
10362 for(int i=0; i< encBufSize; i++)
10364 printf("%x",encBuf[i]);
10369 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
10371 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Failure Message");
10379 FreeRicSubscriptionModificationFailure(e2apMsg);
10383 /*******************************************************************
10384 * @brief Free RIC Subscription Modification Response Message
10388 * Function : FreeRicSubscriptionModificationResponse
10390 * Functionality: Free RIC Subscription Modification Response
10392 * @param E2AP Message PDU
10395 ******************************************************************/
10396 void FreeRicSubscriptionModificationResponse(E2AP_PDU_t *e2apMsg)
10398 uint8_t ieIdx = 0, elementIdx=0;
10399 RICactions_AddedForModification_List_t *actionsAdded = NULLP;
10400 RICactions_RemovedForModification_List_t *actionsRemoved = NULLP;
10401 RICactions_ModifiedForModification_List_t *actionsModified = NULLP;
10402 RICactions_FailedToBeAddedForModification_List_t *actionsFailedToBeAdded = NULLP;
10403 RICactions_FailedToBeRemovedForModification_List_t *actionsFailedToBeRemoved = NULLP;
10404 RICactions_FailedToBeModifiedForModification_List_t *actionsFailedToBeModified = NULLP;
10406 RICsubscriptionModificationResponse_t *ricSubsModResponse = NULLP;
10410 if(e2apMsg->choice.successfulOutcome)
10412 ricSubsModResponse = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse;
10413 if(ricSubsModResponse->protocolIEs.list.array)
10415 for(ieIdx = 0; ieIdx < ricSubsModResponse->protocolIEs.list.count; ieIdx++)
10417 if(ricSubsModResponse->protocolIEs.list.array[ieIdx])
10419 switch(ricSubsModResponse->protocolIEs.list.array[ieIdx]->id)
10421 case ProtocolIE_IDE2_id_RANfunctionID:
10422 case ProtocolIE_IDE2_id_RICrequestID:
10424 case ProtocolIE_IDE2_id_RICactionsRemovedForModification_List:
10426 actionsRemoved = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_RemovedForModification_List;
10427 if(actionsRemoved->list.array)
10429 for(elementIdx = 0; elementIdx < actionsRemoved->list.count; elementIdx++)
10431 DU_FREE(actionsRemoved->list.array[elementIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t));
10433 DU_FREE(actionsRemoved->list.array, actionsRemoved->list.size);
10438 case ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List:
10440 actionsFailedToBeRemoved = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeRemovedForModification_List;
10441 if(actionsFailedToBeRemoved->list.array)
10443 for(elementIdx = 0; elementIdx < actionsFailedToBeRemoved->list.count; elementIdx++)
10445 DU_FREE(actionsFailedToBeRemoved->list.array[elementIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t));
10447 DU_FREE(actionsFailedToBeRemoved->list.array, actionsFailedToBeRemoved->list.size);
10451 case ProtocolIE_IDE2_id_RICactionsModifiedForModification_List:
10453 actionsModified = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_ModifiedForModification_List;
10454 if(actionsModified->list.array)
10456 for(elementIdx = 0; elementIdx < actionsModified->list.count; elementIdx++)
10458 DU_FREE(actionsModified->list.array[elementIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t));
10460 DU_FREE(actionsModified->list.array, actionsModified->list.size);
10464 case ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List:
10466 actionsFailedToBeModified = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeModifiedForModification_List;
10467 if(actionsFailedToBeModified->list.array)
10469 for(elementIdx = 0; elementIdx < actionsFailedToBeModified->list.count; elementIdx++)
10471 DU_FREE(actionsFailedToBeModified->list.array[elementIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t));
10473 DU_FREE(actionsFailedToBeModified->list.array, actionsFailedToBeModified->list.size);
10477 case ProtocolIE_IDE2_id_RICactionsAddedForModification_List:
10479 actionsAdded = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_AddedForModification_List;
10480 if(actionsAdded->list.array)
10482 for(elementIdx = 0; elementIdx < actionsAdded->list.count; elementIdx++)
10484 DU_FREE(actionsAdded->list.array[elementIdx], sizeof(RICaction_AddedForModification_ItemIEs_t));
10486 DU_FREE(actionsAdded->list.array, actionsAdded->list.size);
10490 case ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List:
10492 actionsFailedToBeAdded = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeAddedForModification_List;
10493 if(actionsFailedToBeAdded->list.array)
10495 for(elementIdx = 0; elementIdx < actionsFailedToBeAdded->list.count; elementIdx++)
10497 DU_FREE(actionsFailedToBeAdded->list.array[elementIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t));
10499 DU_FREE(actionsFailedToBeAdded->list.array, actionsFailedToBeAdded->list.size);
10504 DU_FREE(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t));
10507 DU_FREE(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size);
10509 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
10511 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
10515 /*******************************************************************
10517 * @brief Build Ric subscription action removed list
10521 * Function : BuildActionRemovedList
10523 * Functionality: Build Ric subs action removed list
10526 * RICactions_RemovedForModification_List_t to be filled
10527 * Num Of Action removed
10528 * Action removed list
10530 * @return ROK - success
10531 * RFAILED - failure
10533 ******************************************************************/
10535 uint8_t BuildActionRemovedList(RICactions_RemovedForModification_List_t *removedActionList, uint8_t numOfActionRemoved, uint8_t *actionRemoved)
10538 RICaction_RemovedForModification_ItemIEs_t *removedActionItemIe =NULLP;
10540 removedActionList->list.count = numOfActionRemoved;
10541 removedActionList->list.size = removedActionList->list.count * sizeof(RICaction_RemovedForModification_ItemIEs_t*);
10542 DU_ALLOC(removedActionList->list.array, removedActionList->list.size);
10543 if(!removedActionList->list.array)
10545 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10549 for(arrIdx = 0; arrIdx< removedActionList->list.count; arrIdx++)
10551 DU_ALLOC(removedActionList->list.array[arrIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t));
10552 if(!removedActionList->list.array[arrIdx])
10554 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10557 removedActionItemIe = (RICaction_RemovedForModification_ItemIEs_t*)removedActionList->list.array[arrIdx];
10558 removedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_RemovedForModification_Item;
10559 removedActionItemIe->criticality = CriticalityE2_ignore;
10560 removedActionItemIe->value.present = RICaction_RemovedForModification_ItemIEs__value_PR_RICaction_RemovedForModification_Item;
10561 removedActionItemIe->value.choice.RICaction_RemovedForModification_Item.ricActionID = actionRemoved[arrIdx];
10566 /*******************************************************************
10568 * @brief Build Ric subscription action added list
10572 * Function : BuildActionAddedList
10574 * Functionality: Build Ric subs action added list
10577 * RICactions_AddedForModification_List_t to be filled
10578 * Num Of Action added
10579 * Action added list
10581 * @return ROK - success
10582 * RFAILED - failure
10584 ******************************************************************/
10586 uint8_t BuildActionAddedList(RICactions_AddedForModification_List_t *addedActionList, uint8_t numOfActionAdded, uint8_t *actionAdded)
10589 RICaction_AddedForModification_ItemIEs_t *addedActionItemIe =NULLP;
10591 addedActionList->list.count = numOfActionAdded;
10592 addedActionList->list.size = addedActionList->list.count * sizeof(RICaction_AddedForModification_ItemIEs_t*);
10593 DU_ALLOC(addedActionList->list.array, addedActionList->list.size);
10594 if(!addedActionList->list.array)
10596 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10600 for(arrIdx = 0; arrIdx< addedActionList->list.count; arrIdx++)
10602 DU_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_AddedForModification_ItemIEs_t));
10603 if(!addedActionList->list.array[arrIdx])
10605 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10608 addedActionItemIe = (RICaction_AddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx];
10609 addedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_AddedForModification_Item;
10610 addedActionItemIe->criticality = CriticalityE2_ignore;
10611 addedActionItemIe->value.present = RICaction_AddedForModification_ItemIEs__value_PR_RICaction_AddedForModification_Item;
10612 addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID = actionAdded[arrIdx];
10617 /*******************************************************************
10619 * @brief Build Ric subscription action modified list
10623 * Function : BuildActionModifiedList
10625 * Functionality: Build Ric subs action modified list
10628 * RICactions_ModifiedForModification_List_t to be filled
10629 * Num Of Action modified
10630 * Action modified list
10632 * @return ROK - success
10633 * RFAILED - failure
10635 ******************************************************************/
10637 uint8_t BuildActionModifiedList(RICactions_ModifiedForModification_List_t *modifiedActionList, uint8_t numOfActionModified, uint8_t *actionModified)
10640 RICaction_ModifiedForModification_ItemIEs_t *modifiedActionItemIe =NULLP;
10642 modifiedActionList->list.count = numOfActionModified;
10643 modifiedActionList->list.size = modifiedActionList->list.count * sizeof(RICaction_ModifiedForModification_ItemIEs_t*);
10644 DU_ALLOC(modifiedActionList->list.array, modifiedActionList->list.size);
10645 if(!modifiedActionList->list.array)
10647 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10651 for(arrIdx = 0; arrIdx< modifiedActionList->list.count; arrIdx++)
10653 DU_ALLOC(modifiedActionList->list.array[arrIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t));
10654 if(!modifiedActionList->list.array[arrIdx])
10656 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10659 modifiedActionItemIe = (RICaction_ModifiedForModification_ItemIEs_t*)modifiedActionList->list.array[arrIdx];
10660 modifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ModifiedForModification_Item;
10661 modifiedActionItemIe->criticality = CriticalityE2_ignore;
10662 modifiedActionItemIe->value.present = RICaction_ModifiedForModification_ItemIEs__value_PR_RICaction_ModifiedForModification_Item;
10663 modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID = actionModified[arrIdx];
10668 /*******************************************************************
10670 * @brief Build Ric subscription action failed to be removed list
10674 * Function : BuildActionFailedToBeRemovedList
10676 * Functionality: Build Ric subs action failed to be removed list
10679 * RICactions_FailedToBeRemovedForModification_List_t to be filled
10680 * Num Of Action failed to be removed
10681 * Action failed to be removed list
10683 * @return ROK - success
10684 * RFAILED - failure
10686 ******************************************************************/
10688 uint8_t BuildActionFailedToBeRemovedList(RICactions_FailedToBeRemovedForModification_List_t *failedToBeRemovedActionList,\
10689 uint8_t numOfActionFailedToBeRemoved, RejectedAction *actionFailedToBeRemoved)
10692 RICaction_FailedToBeRemovedForModification_ItemIEs_t *failedToBeRemovedActionItemIe =NULLP;
10694 failedToBeRemovedActionList->list.count = numOfActionFailedToBeRemoved;
10695 failedToBeRemovedActionList->list.size = failedToBeRemovedActionList->list.count * sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t*);
10696 DU_ALLOC(failedToBeRemovedActionList->list.array, failedToBeRemovedActionList->list.size);
10697 if(!failedToBeRemovedActionList->list.array)
10699 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10703 for(arrIdx = 0; arrIdx< failedToBeRemovedActionList->list.count; arrIdx++)
10705 DU_ALLOC(failedToBeRemovedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t));
10706 if(!failedToBeRemovedActionList->list.array[arrIdx])
10708 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10711 failedToBeRemovedActionItemIe = (RICaction_FailedToBeRemovedForModification_ItemIEs_t*)failedToBeRemovedActionList->list.array[arrIdx];
10712 failedToBeRemovedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeRemovedForModification_Item;
10713 failedToBeRemovedActionItemIe->criticality = CriticalityE2_ignore;
10714 failedToBeRemovedActionItemIe->value.present = RICaction_FailedToBeRemovedForModification_ItemIEs__value_PR_RICaction_FailedToBeRemovedForModification_Item;
10715 failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID = actionFailedToBeRemoved[arrIdx].id;
10716 fillE2Cause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause, actionFailedToBeRemoved[arrIdx].failureCause);
10721 /*******************************************************************
10723 * @brief Build Ric subscription action failed to be modified list
10727 * Function : BuildActionFailedToBeModifiedList
10729 * Functionality: Build Ric subs action failed to be modified list
10732 * RICactions_FailedToBeModifiedForModification_List_t to be filled
10733 * Num Of Action failed to be modified
10734 * Action failed to be modified list
10736 * @return ROK - success
10737 * RFAILED - failure
10739 ******************************************************************/
10741 uint8_t BuildActionFailedToBeModifiedList(RICactions_FailedToBeModifiedForModification_List_t *failedToBeModifiedActionList,\
10742 uint8_t numOfActionFailedToBeModified, RejectedAction *actionFailedToBeModified)
10745 RICaction_FailedToBeModifiedForModification_ItemIEs_t *failedToBeModifiedActionItemIe =NULLP;
10747 failedToBeModifiedActionList->list.count = numOfActionFailedToBeModified;
10748 failedToBeModifiedActionList->list.size = failedToBeModifiedActionList->list.count * sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t*);
10749 DU_ALLOC(failedToBeModifiedActionList->list.array, failedToBeModifiedActionList->list.size);
10750 if(!failedToBeModifiedActionList->list.array)
10752 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10756 for(arrIdx = 0; arrIdx< failedToBeModifiedActionList->list.count; arrIdx++)
10758 DU_ALLOC(failedToBeModifiedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t));
10759 if(!failedToBeModifiedActionList->list.array[arrIdx])
10761 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10764 failedToBeModifiedActionItemIe = (RICaction_FailedToBeModifiedForModification_ItemIEs_t*)failedToBeModifiedActionList->list.array[arrIdx];
10765 failedToBeModifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeModifiedForModification_Item;
10766 failedToBeModifiedActionItemIe->criticality = CriticalityE2_ignore;
10767 failedToBeModifiedActionItemIe->value.present = RICaction_FailedToBeModifiedForModification_ItemIEs__value_PR_RICaction_FailedToBeModifiedForModification_Item;
10768 failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID = actionFailedToBeModified[arrIdx].id;
10769 fillE2Cause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause, actionFailedToBeModified[arrIdx].failureCause);
10774 /*******************************************************************
10776 * @brief Build Ric subscription action failed to be added list
10780 * Function : BuildActionFailedToBeAddedList
10782 * Functionality: Build Ric subs action failed to be added list
10785 * RICactions_FailedToBeAddedForModification_List_t to be filled
10786 * Num Of Action failed to be added
10787 * Action failed to be added list
10789 * @return ROK - success
10790 * RFAILED - failure
10792 ******************************************************************/
10794 uint8_t BuildActionFailedToBeAddedList(RICactions_FailedToBeAddedForModification_List_t *failedToBeAddedActionList, uint8_t numOfActionFailedToBeAdded, RejectedAction *actionFailedToBeAdded)
10797 RICaction_FailedToBeAddedForModification_ItemIEs_t *failedToBeAddedActionItemIe =NULLP;
10799 failedToBeAddedActionList->list.count = numOfActionFailedToBeAdded;
10800 failedToBeAddedActionList->list.size = failedToBeAddedActionList->list.count * sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t*);
10801 DU_ALLOC(failedToBeAddedActionList->list.array, failedToBeAddedActionList->list.size);
10802 if(!failedToBeAddedActionList->list.array)
10804 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10808 for(arrIdx = 0; arrIdx< failedToBeAddedActionList->list.count; arrIdx++)
10810 DU_ALLOC(failedToBeAddedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t));
10811 if(!failedToBeAddedActionList->list.array[arrIdx])
10813 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10816 failedToBeAddedActionItemIe = (RICaction_FailedToBeAddedForModification_ItemIEs_t*)failedToBeAddedActionList->list.array[arrIdx];
10817 failedToBeAddedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeAddedForModification_Item;
10818 failedToBeAddedActionItemIe->criticality = CriticalityE2_ignore;
10819 failedToBeAddedActionItemIe->value.present = RICaction_FailedToBeAddedForModification_ItemIEs__value_PR_RICaction_FailedToBeAddedForModification_Item;
10820 failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.ricActionID = actionFailedToBeAdded[arrIdx].id;
10821 fillE2Cause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause, actionFailedToBeAdded[arrIdx].failureCause);
10826 /*******************************************************************
10828 * @brief Builds and Send RIC Subscription Modification Response
10832 * Function : BuildAndSendRicSubscriptionModificationResponse
10834 * Functionality: Build and send RIC Subscription Modification Response.
10837 * PendingSubsModRspInfo
10838 * @return ROK - success
10839 * RFAILED - failure
10841 ******************************************************************/
10842 uint8_t BuildAndSendRicSubscriptionModificationResponse(PendingSubsModRspInfo *pendingSubsModRsp)
10844 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
10845 E2AP_PDU_t *e2apMsg = NULLP;
10846 RICsubscriptionModificationResponse_t *ricSubsModResponse = NULLP;
10847 RICsubscriptionModificationResponse_IEs_t *ricSubsModResponseIe = NULLP;
10848 asn_enc_rval_t encRetVal; /* Encoder return value */
10852 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Response Message\n");
10854 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
10855 if(e2apMsg == NULLP)
10857 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10861 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
10862 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
10863 if(e2apMsg->choice.successfulOutcome == NULLP)
10865 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10868 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
10869 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
10870 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationResponse;
10873 ricSubsModResponse = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse;
10876 if(pendingSubsModRsp->removeActionStatus.numOfAcceptedActions)
10878 if(pendingSubsModRsp->addActionStatus.numOfAcceptedActions)
10880 if(pendingSubsModRsp->modActionStatus.numOfAcceptedActions)
10882 if(pendingSubsModRsp->removeActionStatus.numOfRejectedActions)
10884 if(pendingSubsModRsp->addActionStatus.numOfRejectedActions)
10886 if(pendingSubsModRsp->modActionStatus.numOfRejectedActions)
10889 ricSubsModResponse->protocolIEs.list.count = elementCnt;
10890 ricSubsModResponse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationResponse_IEs_t *);
10892 DU_ALLOC(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size);
10893 if(ricSubsModResponse->protocolIEs.list.array == NULLP)
10895 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10899 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
10901 DU_ALLOC(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t));
10902 if(ricSubsModResponse->protocolIEs.list.array[ieIdx] == NULLP)
10904 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10908 if(ieIdx < elementCnt)
10912 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10913 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICrequestID;
10914 ricSubsModResponseIe->criticality = CriticalityE2_reject;
10915 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICrequestID;
10916 ricSubsModResponseIe->value.choice.RICrequestID.ricRequestorID= pendingSubsModRsp->requestId.requestorId;
10917 ricSubsModResponseIe->value.choice.RICrequestID.ricInstanceID = pendingSubsModRsp->requestId.instanceId;
10920 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10921 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RANfunctionID;
10922 ricSubsModResponseIe->criticality = CriticalityE2_reject;
10923 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RANfunctionID;
10924 ricSubsModResponseIe->value.choice.RANfunctionID = pendingSubsModRsp->ranFuncId;
10926 if(pendingSubsModRsp->removeActionStatus.numOfAcceptedActions)
10929 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10930 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsRemovedForModification_List;
10931 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10932 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_RemovedForModification_List;
10933 if(BuildActionRemovedList(&ricSubsModResponseIe->value.choice.RICactions_RemovedForModification_List,\
10934 pendingSubsModRsp->removeActionStatus.numOfAcceptedActions, pendingSubsModRsp->removeActionStatus.acceptedActionList) != ROK)
10936 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10941 if(pendingSubsModRsp->removeActionStatus.numOfRejectedActions)
10944 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10945 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List;
10946 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10947 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeRemovedForModification_List;
10948 if(BuildActionFailedToBeRemovedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeRemovedForModification_List,\
10949 pendingSubsModRsp->removeActionStatus.numOfRejectedActions, pendingSubsModRsp->removeActionStatus.rejectedActionList) != ROK)
10951 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10956 if(pendingSubsModRsp->modActionStatus.numOfAcceptedActions)
10959 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10960 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsModifiedForModification_List;
10961 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10962 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_ModifiedForModification_List;
10963 if(BuildActionModifiedList(&ricSubsModResponseIe->value.choice.RICactions_ModifiedForModification_List,\
10964 pendingSubsModRsp->modActionStatus.numOfAcceptedActions, pendingSubsModRsp->modActionStatus.acceptedActionList) != ROK)
10966 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10971 if(pendingSubsModRsp->modActionStatus.numOfRejectedActions)
10974 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10975 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List;
10976 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10977 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeModifiedForModification_List;
10978 if(BuildActionFailedToBeModifiedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeModifiedForModification_List,\
10979 pendingSubsModRsp->modActionStatus.numOfRejectedActions, pendingSubsModRsp->modActionStatus.rejectedActionList) != ROK)
10981 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10986 if(pendingSubsModRsp->addActionStatus.numOfAcceptedActions)
10989 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10990 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsAddedForModification_List;
10991 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10992 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_AddedForModification_List;
10993 if(BuildActionAddedList(&ricSubsModResponseIe->value.choice.RICactions_AddedForModification_List,\
10994 pendingSubsModRsp->addActionStatus.numOfAcceptedActions, pendingSubsModRsp->addActionStatus.acceptedActionList) != ROK)
10996 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
11001 if(pendingSubsModRsp->addActionStatus.numOfRejectedActions)
11004 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
11005 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List;
11006 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
11007 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeAddedForModification_List;
11008 if(BuildActionFailedToBeAddedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeAddedForModification_List,\
11009 pendingSubsModRsp->addActionStatus.numOfRejectedActions, pendingSubsModRsp->addActionStatus.rejectedActionList) != ROK)
11011 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
11016 /* Prints the Msg formed */
11017 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
11018 memset(encBuf, 0, ENC_BUF_MAX_LEN);
11020 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
11021 if(encRetVal.encoded == ENCODE_FAIL)
11023 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Response Message (at %s)\n",\
11024 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11029 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Response Message \n");
11030 #ifdef DEBUG_ASN_PRINT
11031 for(int i=0; i< encBufSize; i++)
11033 printf("%x",encBuf[i]);
11038 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
11040 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Response Message");
11048 FreeRicSubscriptionModificationResponse(e2apMsg);
11052 /*******************************************************************
11054 * @brief Handles received E2AP message and sends back response
11058 * Function : E2APMsgHdlr
11061 * - Decodes received E2AP control message
11062 * - Prepares response message, encodes and sends to SCTP
11065 * @return ROK - success
11066 * RFAILED - failure
11068 * ****************************************************************/
11069 void E2APMsgHdlr(Buffer *mBuf)
11072 char *recvBuf = NULLP;
11074 MsgLen recvBufLen =0;
11075 E2AP_PDU_t *e2apMsg = NULLP;
11076 asn_dec_rval_t rval ={0}; /* Decoder return value */
11077 E2AP_PDU_t e2apasnmsg={0} ;
11079 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
11080 ODU_PRINT_MSG(mBuf, 0,0);
11082 /* Copy mBuf into char array to decode it */
11083 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
11084 DU_ALLOC(recvBuf, (Size)recvBufLen);
11086 if(recvBuf == NULLP)
11088 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
11091 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
11093 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
11097 #ifdef DEBUG_ASN_PRINT
11098 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
11099 for(i=0; i< recvBufLen; i++)
11101 printf("%x",recvBuf[i]);
11105 /* Decoding flat buffer into E2AP messsage */
11106 e2apMsg = &e2apasnmsg;
11107 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
11109 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
11110 DU_FREE(recvBuf, (Size)recvBufLen);
11112 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11114 DU_LOG("\nERROR --> E2AP : ASN decode failed");
11118 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
11120 switch(e2apMsg->present)
11122 case E2AP_PDU_PR_unsuccessfulOutcome:
11124 switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
11126 case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
11128 procE2SetupFailure(e2apMsg);
11131 case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure:
11133 procE2NodeConfigUpdateFailure(e2apMsg);
11136 case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure:
11138 procRicServiceUpdateFailure(e2apMsg);
11141 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse:
11143 procRicSubscriptionModificationRefuse(e2apMsg);
11146 case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
11148 ProcE2RemovalFailure(e2apMsg);
11153 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
11154 e2apMsg->choice.unsuccessfulOutcome->value.present);
11158 free(e2apMsg->choice.unsuccessfulOutcome);
11161 case E2AP_PDU_PR_successfulOutcome:
11163 switch(e2apMsg->choice.successfulOutcome->value.present)
11165 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
11169 procE2SetupRsp(e2apMsg);
11173 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
11175 procResetResponse(e2apMsg);
11178 case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge:
11180 procRicServiceUpdateAck(e2apMsg);
11183 case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm:
11185 procRicSubscriptionModificationConfirm(e2apMsg);
11188 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
11190 procE2NodeConfigUpdateAck(e2apMsg);
11193 case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
11195 ProcE2RemovalResponse(e2apMsg);
11200 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
11201 e2apMsg->choice.successfulOutcome->value.present);
11204 }/* End of switch(successfulOutcome) */
11205 free(e2apMsg->choice.successfulOutcome);
11209 case E2AP_PDU_PR_initiatingMessage:
11211 switch(e2apMsg->choice.initiatingMessage->value.present)
11213 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
11215 procRicSubscriptionRequest(e2apMsg);
11218 case InitiatingMessageE2__value_PR_RICserviceQuery:
11220 procRicServiceQuery(e2apMsg);
11223 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
11225 DU_LOG("\nINFO --> E2AP : Error indication received");
11228 case InitiatingMessageE2__value_PR_ResetRequestE2:
11230 DU_LOG("\nINFO --> E2AP : Reset request received");
11231 procE2ResetRequest(e2apMsg);
11234 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest:
11236 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Request received");
11237 procRicSubscriptionDeleteRequest(e2apMsg);
11240 case InitiatingMessageE2__value_PR_E2RemovalRequest:
11242 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
11243 procE2RemovalRequest(e2apMsg);
11246 case InitiatingMessageE2__value_PR_E2connectionUpdate:
11248 DU_LOG("\nINFO --> E2AP : E2 coneection update received");
11249 procE2ConnectionUpdate(e2apMsg);
11252 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest:
11254 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Request received");
11255 procRicSubscriptionModificationRequest(e2apMsg);
11260 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
11261 e2apMsg->choice.initiatingMessage->value.present);
11264 }/* End of switch(initiatingMessage) */
11265 free(e2apMsg->choice.initiatingMessage);
11270 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
11275 }/* End of switch(e2apMsg->present) */
11277 } /* End of E2APMsgHdlr */
11279 /**********************************************************************
11281 **********************************************************************/