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));
1421 DU_FREE(measInfoList,ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.size);
1423 DU_FREE(ricReportStyle->list.array[reportStyleIdx], sizeof(RIC_ReportStyle_Item_t));
1426 DU_FREE(ricReportStyle->list.array, ricReportStyle->list.size);
1428 DU_FREE(ricReportStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1430 DU_FREE(ranFunctionDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1434 /*******************************************************************
1436 * @brief fill the e2sm ric report style
1440 * Function : fillRicReportStyle
1442 * Functionality: fill the report style
1444 * @params[in] RanFunction *ranFuncDb, struct
1445 * E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle
1446 * @return ROK - success
1449 ******************************************************************/
1450 uint8_t fillRicReportStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle)
1452 uint8_t styleIdx, measInfoIdx;
1453 MeasurementInfo_Action_List_t *measInfo;
1456 ricReportStyle->list.count = ranFuncDb->numOfReportStyleSupported;
1457 ricReportStyle->list.size = ricReportStyle->list.count * sizeof(RIC_ReportStyle_Item_t*);
1458 DU_ALLOC(ricReportStyle->list.array, ricReportStyle->list.size);
1459 if(!ricReportStyle->list.array)
1461 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__);
1465 for(styleIdx =0;styleIdx<ricReportStyle->list.count; styleIdx++)
1467 DU_ALLOC(ricReportStyle->list.array[styleIdx], sizeof(RIC_ReportStyle_Item_t));
1468 if(!ricReportStyle->list.array[styleIdx])
1470 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1474 /* RIC Report Style Type */
1475 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType;
1477 /* RIC Report Style Format Type */
1478 ricReportStyle->list.array[styleIdx]->ric_ActionFormat_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType;
1480 /* RIC Report Style Name */
1481 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size = strlen(ranFuncDb->reportStyleList[styleIdx].reportStyle.name);
1482 DU_ALLOC(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf,\
1483 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1484 if(!ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf)
1486 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1489 memcpy(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf, ranFuncDb->reportStyleList[styleIdx].reportStyle.name,\
1490 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1492 /* RIC Indication Header Format Type*/
1493 ricReportStyle->list.array[styleIdx]->ric_IndicationHeaderFormat_Type = ranFuncDb->ricIndicationHeaderFormat;
1495 /* RIC Indication Message Format Type*/
1496 ricReportStyle->list.array[styleIdx]->ric_IndicationMessageFormat_Type = ranFuncDb->ricIndicationMessageFormat;
1498 /* Measurement Info Action List */
1499 CmLListCp measInfoList =ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
1500 if(!measInfoList.count)
1505 CM_LLIST_FIRST_NODE(&ranFuncDb->reportStyleList[styleIdx].measurementInfoList, node);
1506 measInfo = &ricReportStyle->list.array[styleIdx]->measInfo_Action_List;
1508 measInfo->list.count = measInfoList.count;
1509 measInfo->list.size = measInfoList.count*sizeof(MeasurementInfo_Action_Item_t*);
1510 DU_ALLOC(measInfo->list.array, measInfo->list.size);
1511 if(!measInfo->list.array)
1513 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1517 for(measInfoIdx=0; measInfoIdx<measInfo->list.count; measInfoIdx++)
1521 DU_LOG("\nERROR --> E2AP: Measurement info node is null");
1525 DU_ALLOC(measInfo->list.array[measInfoIdx],sizeof(MeasurementInfo_Action_Item_t));
1526 if(!measInfo->list.array[measInfoIdx])
1528 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1531 MeasurementInfoForAction *measInfoForAction= (MeasurementInfoForAction*)node->node;
1532 DU_ALLOC(measInfo->list.array[measInfoIdx]->measID, sizeof(long));
1533 if(!measInfo->list.array[measInfoIdx]->measID)
1535 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1539 memcpy(measInfo->list.array[measInfoIdx]->measID, &measInfoForAction->measurementTypeId,sizeof(long));
1540 measInfo->list.array[measInfoIdx]->measName.size= strlen(measInfoForAction->measurementTypeName);
1541 DU_ALLOC(measInfo->list.array[measInfoIdx]->measName.buf, measInfo->list.array[measInfoIdx]->measName.size);
1542 if(!measInfo->list.array[measInfoIdx]->measName.size)
1544 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1548 memcpy(measInfo->list.array[measInfoIdx]->measName.buf, \
1549 measInfoForAction->measurementTypeName,\
1550 measInfo->list.array[measInfoIdx]->measName.size);
1557 /*******************************************************************
1559 * @brief fill the ric event trigger style
1563 * Function : fillRicEventTriggerStyle
1565 * Functionality: fill the ric event trigger style
1568 * @return ROK - success
1571 ******************************************************************/
1572 uint8_t fillRicEventTriggerStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *ricEventTriggerStyle)
1576 ricEventTriggerStyle->list.count = ranFuncDb->numOfEventTriggerStyleSupported;
1577 ricEventTriggerStyle->list.size = ricEventTriggerStyle->list.count* sizeof(RIC_EventTriggerStyle_Item_t *);
1578 DU_ALLOC(ricEventTriggerStyle->list.array, ricEventTriggerStyle->list.size);
1579 if(!ricEventTriggerStyle->list.array)
1581 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__);
1585 for(styleIdx =0;styleIdx<ricEventTriggerStyle->list.count; styleIdx++)
1587 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
1588 if(!ricEventTriggerStyle->list.array[styleIdx])
1590 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1593 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Type = ranFuncDb->eventTriggerStyleList[styleIdx].styleType;
1595 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerFormat_Type = ranFuncDb->eventTriggerStyleList[styleIdx].formatType;
1597 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size = strlen(ranFuncDb->eventTriggerStyleList[styleIdx].name);
1598 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,\
1599 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1600 if(!ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf)
1602 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1605 memcpy(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,ranFuncDb->eventTriggerStyleList[styleIdx].name,\
1606 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1612 /*******************************************************************
1614 * @brief Builds Ran function item
1618 * Function : BuildRanFunctionItem
1620 * Functionality: Building RAN function item
1623 * RAN function item that has to be filled
1624 * Stored RAN Function information
1625 * @return ROK - success
1628 ******************************************************************/
1630 uint8_t BuildRanFunctionItem(RANfunction_Item_t *ranFuncItem, RanFunction *ranFuncDb)
1632 uint8_t ret =RFAILED;
1633 RANfunctionDefinition_t *ranFunctionDefinition;
1634 RANfunction_Name_t *ranFuncName;
1635 asn_enc_rval_t encRetVal;
1636 E2SM_KPM_RANfunction_Description_t *ranFuncDefinition;
1640 /* RAN function Id*/
1641 ranFuncItem->ranFunctionID = ranFuncDb->id;
1643 /* RAN Function Revision*/
1644 ranFuncItem->ranFunctionRevision = ranFuncDb->revisionCounter;
1646 /* RAN function OID*/
1647 ranFuncItem->ranFunctionOID.size = strlen(ranFuncDb->name.serviceModelOID);
1648 DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size);
1649 if(!ranFuncItem->ranFunctionOID.buf)
1651 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1654 memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size);
1656 /* RAN function Definition */
1657 DU_ALLOC(ranFuncDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1658 if(!ranFuncDefinition)
1660 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1664 /* RAN function Name */
1665 ranFuncName = &ranFuncDefinition->ranFunction_Name;
1667 /* RAN function ShortName */
1668 ranFuncName->ranFunction_ShortName.size = strlen(ranFuncDb->name.shortName);
1669 DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
1670 if(!ranFuncName->ranFunction_ShortName.buf)
1672 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1675 memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName));
1677 /* RAN function E2SM_OID */
1678 ranFuncName->ranFunction_E2SM_OID.size = strlen(ranFuncDb->name.serviceModelOID);
1679 DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
1680 if(!ranFuncName->ranFunction_E2SM_OID.buf)
1682 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1685 memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
1687 /* RAN Function Name Description */
1688 ranFuncName->ranFunction_Description.size = strlen(ranFuncDb->name.description);
1689 DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
1690 if(!ranFuncName->ranFunction_Description.buf)
1692 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1695 memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size);
1697 /* RIC Event Trigger Style List */
1698 DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
1699 if(!ranFuncDefinition->ric_EventTriggerStyle_List)
1701 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1705 if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
1707 DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
1711 /* RIC Report Style List */
1712 DU_ALLOC(ranFuncDefinition->ric_ReportStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1713 if(!ranFuncDefinition->ric_ReportStyle_List)
1715 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1718 if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
1720 DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
1724 /* Encode the F1SetupRequest type as APER */
1725 xer_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, ranFuncDefinition);
1727 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1729 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_RANfunction_Description, 0, ranFuncDefinition, PrepFinalEncBuf, encBuf);
1731 /* Encode results */
1732 if(encRetVal.encoded == ENCODE_FAIL)
1734 DU_LOG("\nERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\
1735 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1740 DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n");
1741 for(uint8_t measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
1743 printf("%x",encBuf[measIeIdx]);
1745 ranFunctionDefinition = &ranFuncItem->ranFunctionDefinition;
1746 ranFunctionDefinition->size = encBufSize;
1747 DU_ALLOC(ranFunctionDefinition->buf, encBufSize);
1748 if(ranFunctionDefinition->buf == NULLP)
1750 DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
1753 memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize);
1758 freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
1762 /*******************************************************************
1764 * @brief Builds Ran function add list based on the procedure code
1768 * Function : BuildRanFunctionAddList
1770 * Functionality: Building RAN addition addition list
1771 * In case of ProcedureCodeE2_id_E2setup we add all the RAN Function list
1772 * which is present in E2 database.
1773 * In the case of other procedures, we just fill the RAN functions whose ID
1774 * is contained in recvList
1779 * Count of ran functions to be added in the list
1780 * Received list of RAN functions
1782 * @return ROK - success
1785 ******************************************************************/
1787 uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList, uint8_t procedureCode, uint8_t count, RanFuncInfo *recvList)
1790 RanFunction *ranFuncDb;
1792 RANfunction_ItemIEs_t *ranFuncItemIe;
1794 /* For ProcedureCodeE2_id_E2setup, the number of RAN function list items is
1795 * equal to the number of ran function entries stored in the database.
1796 * For any other procedure, the RAN function list count is equal
1797 * to the count of ran functions obtained from the function's caller */
1799 if(procedureCode == ProcedureCodeE2_id_E2setup)
1800 ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
1802 ranFunctionsList->list.count = count;
1804 ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*);
1805 DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
1806 if(ranFunctionsList->list.array == NULLP)
1808 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1812 for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++)
1814 DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1815 if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
1817 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1820 if(procedureCode == ProcedureCodeE2_id_E2setup)
1822 /* Getting all of the RAN function's information from DuCb one by one*/
1823 ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
1827 /* Getting only the RAN function information from DuCb whose Id is
1828 * present in the received array */
1829 id =recvList[ranFuncIdx].id;
1830 ranFuncDb = &duCb.e2apDb.ranFunction[id-1];
1832 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1833 ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item;
1834 ranFuncItemIe->criticality = CriticalityE2_ignore;
1835 ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
1836 BuildRanFunctionItem(&ranFuncItemIe->value.choice.RANfunction_Item, ranFuncDb);
1841 /*******************************************************************
1843 * @brief De Allocate E2 Setup Request Message
1847 * Function : FreeE2SetupReq
1849 * Functionality: De-Allocating E2 Setup request Message
1851 * @params[in] E2AP_PDU_t *e2apMsg
1855 * ****************************************************************/
1857 void FreeE2SetupReq(E2AP_PDU_t *e2apMsg)
1860 uint8_t e2NodeAddListIdx =0, ranFuncAddListIdx;
1861 E2setupRequest_t *e2SetupReq;
1862 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1863 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1864 RANfunctions_List_t *ranFunctionsList;
1865 RANfunction_ItemIEs_t *ranFuncItemIe;
1866 RANfunction_Item_t *ranFunItem;
1868 /* De-allocating Memory */
1869 if(e2apMsg != NULLP)
1871 if(e2apMsg->choice.initiatingMessage != NULLP)
1873 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
1874 if(e2SetupReq->protocolIEs.list.array != NULLP)
1876 for(arrIdx = 0; arrIdx < e2SetupReq->protocolIEs.list.count; arrIdx++)
1878 if(e2SetupReq->protocolIEs.list.array[arrIdx] != NULLP)
1880 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1882 case ProtocolIE_IDE2_id_TransactionID:
1884 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1886 if(e2SetupReq->protocolIEs.list.array[arrIdx]->\
1887 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
1889 GlobalE2node_gNB_ID_t *gNbId = NULLP;
1890 gNbId = e2SetupReq->protocolIEs.list.array[arrIdx]->\
1891 value.choice.GlobalE2node_ID.choice.gNB;
1892 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
1894 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
1895 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
1896 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
1897 gNbId->global_gNB_ID.plmn_id.size);
1900 if(gNbId->gNB_DU_ID != NULLP)
1902 DU_FREE( gNbId->gNB_DU_ID->buf, gNbId->gNB_DU_ID->size);
1903 DU_FREE(gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
1905 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
1906 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
1910 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1912 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1913 if(e2NodeAddList->list.array)
1915 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1917 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
1919 /* Free E2 Node Component Request Part */
1920 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
1921 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
1923 /* Free E2 Node Component Response Part */
1924 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.\
1925 e2nodeComponentResponsePart.buf, \
1926 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
1928 /* Free E2 Node Component ID */
1929 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1)
1931 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1932 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
1933 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1934 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1935 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
1936 sizeof(E2nodeComponentInterfaceF1_t));
1938 DU_FREE(e2NodeAddList->list.array[e2NodeAddListIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
1940 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
1944 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1946 ranFunctionsList = &(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
1947 if(ranFunctionsList->list.array)
1949 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
1951 if(ranFunctionsList->list.array[ranFuncAddListIdx])
1953 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
1954 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1955 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
1956 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
1957 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
1960 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
1966 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
1967 (e2SetupReq->protocolIEs.list.array[arrIdx]->id));
1970 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx], sizeof(E2setupRequestIEs_t));
1973 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
1975 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1977 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1981 /*******************************************************************
1983 * @brief Builds and Send the E2SetupRequest
1987 * Function : BuildAndSendE2SetupReq
1989 * Functionality:Fills the E2SetupRequest
1991 * @return ROK - success
1994 ******************************************************************/
1996 uint8_t BuildAndSendE2SetupReq()
1998 uint16_t transId = 0;
1999 uint8_t arrIdx = 0, elementCnt=0, ret =RFAILED;
2000 bool memAllocFailed = false;
2001 E2AP_PDU_t *e2apMsg = NULLP;
2002 E2setupRequest_t *e2SetupReq = NULLP;
2003 asn_enc_rval_t encRetVal; /* Encoder return value */
2005 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
2008 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2009 if(e2apMsg == NULLP)
2011 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2014 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2015 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2016 if(e2apMsg->choice.initiatingMessage == NULLP)
2018 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2021 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2022 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
2023 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
2024 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
2027 e2SetupReq->protocolIEs.list.count = elementCnt;
2028 e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*);
2030 /* Initialize the E2Setup members */
2031 DU_ALLOC(e2SetupReq->protocolIEs.list.array, \
2032 e2SetupReq->protocolIEs.list.size);
2033 if(e2SetupReq->protocolIEs.list.array == NULLP)
2035 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
2038 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
2040 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx],\
2041 sizeof(E2setupRequestIEs_t));
2042 if(e2SetupReq->protocolIEs.list.array[arrIdx] == NULLP)
2044 memAllocFailed = true;
2045 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
2049 if(memAllocFailed == true)
2055 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2056 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2057 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
2058 transId = assignTransactionId();
2059 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2062 /* GlobalE2node_gNB_ID */
2063 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
2064 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2065 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
2066 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
2068 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
2069 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
2070 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
2071 GlobalE2node_ID.choice.gNB == NULLP)
2073 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
2078 ret = BuildGlobalgNBId(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
2079 choice.GlobalE2node_ID.choice.gNB);
2082 DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
2087 /* RAN Functions Added List */
2089 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
2090 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2091 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
2092 if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
2094 DU_LOG("\nERROR --> E2AP : Failed to create RAN Function");
2098 /* E2 Node Component Configuration Addition List */
2100 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
2101 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2102 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
2103 if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
2105 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
2111 /* Prints the Msg formed */
2112 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2114 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2116 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
2118 if(encRetVal.encoded == ENCODE_FAIL)
2120 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
2121 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2126 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
2127 #ifdef DEBUG_ASN_PRINT
2128 for(int i=0; i< encBufSize; i++)
2130 printf("%x",encBuf[i]);
2134 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2136 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
2141 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
2142 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
2144 FreeE2SetupReq(e2apMsg);
2146 }/* End of BuildAndSendE2SetupReq */
2148 /*******************************************************************
2150 * @brief Builds RIC Action Admitted List
2154 * Function : BuildRicActionAdmitList
2156 * Functionality: Builds RIC Action Admitted List
2158 * @params[in] Pointer to RIC Action Admitted List to be filled
2159 * Subscription Response information
2160 * @return ROK - success
2163 * ****************************************************************/
2164 uint8_t BuildRicActionAdmitList(RICaction_Admitted_List_t *admitList, PendingSubsRspInfo *subsRspInfo)
2167 uint8_t elementCnt = 0;
2168 RICaction_Admitted_ItemIEs_t *admitItem = NULLP;
2170 elementCnt = subsRspInfo->numOfAcceptedActions;
2172 admitList->list.count = elementCnt;
2173 admitList->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t *);
2175 DU_ALLOC(admitList->list.array, admitList->list.size);
2176 if(admitList->list.array == NULLP)
2178 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2182 for(idx=0; idx<elementCnt; idx++)
2184 DU_ALLOC(admitList->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
2185 if(admitList->list.array[idx] == NULLP)
2187 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2191 admitItem = (RICaction_Admitted_ItemIEs_t *)admitList->list.array[idx];
2192 admitItem->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
2193 admitItem->criticality = CriticalityE2_reject;
2194 admitItem->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
2195 admitItem->value.choice.RICaction_Admitted_Item.ricActionID = subsRspInfo->acceptedActionList[idx];
2200 /*******************************************************************
2202 * @brief Builds RIC Action Not Admitted List
2206 * Function : BuildRicActionNotAdmitList
2208 * Functionality: Builds RIC Action Not Admitted List
2210 * @params[in] Pointer to RIC Action Not Admitted List to be filled
2211 * Subscription Response information
2212 * @return ROK - success
2215 * ****************************************************************/
2216 uint8_t BuildRicActionNotAdmitList(RICaction_NotAdmitted_List_t *notAdmitList, PendingSubsRspInfo *subsRspInfo)
2219 uint8_t elementCnt = 0;
2220 RICaction_NotAdmitted_ItemIEs_t *notAdmitItem = NULLP;
2222 elementCnt = subsRspInfo->numOfRejectedActions;
2224 notAdmitList->list.count = elementCnt;
2225 notAdmitList->list.size = elementCnt * sizeof(RICaction_NotAdmitted_ItemIEs_t *);
2227 DU_ALLOC(notAdmitList->list.array, notAdmitList->list.size);
2228 if(notAdmitList->list.array == NULLP)
2230 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2234 for(idx=0; idx<elementCnt; idx++)
2236 DU_ALLOC(notAdmitList->list.array[idx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
2237 if(notAdmitList->list.array[idx] == NULLP)
2239 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2243 notAdmitItem = (RICaction_NotAdmitted_ItemIEs_t *)notAdmitList->list.array[idx];
2244 notAdmitItem->id = ProtocolIE_IDE2_id_RICaction_NotAdmitted_Item;
2245 notAdmitItem->criticality = CriticalityE2_reject;
2246 notAdmitItem->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;
2247 notAdmitItem->value.choice.RICaction_NotAdmitted_Item.ricActionID = \
2248 subsRspInfo->rejectedActionList[idx].id;
2249 fillE2Cause(¬AdmitItem->value.choice.RICaction_NotAdmitted_Item.cause, \
2250 subsRspInfo->rejectedActionList[idx].failureCause);
2255 /*******************************************************************
2257 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
2261 * Function : FreeRicSubscriptionRsp
2263 * Functionality:Free the RicSubscriptionRsp
2265 * @param[in] E2AP_PDU_t *e2apRicMsg
2269 ******************************************************************/
2270 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
2272 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
2275 RICaction_Admitted_List_t *admitList = NULLP;
2276 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
2278 if(e2apRicMsg != NULLP)
2280 if(e2apRicMsg->choice.successfulOutcome != NULLP)
2282 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2283 if(ricSubscriptionRsp)
2285 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
2287 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
2289 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
2291 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
2293 case ProtocolIE_IDE2_id_RICactions_Admitted:
2295 admitList = &ricSubscriptionRsp->protocolIEs.list.\
2296 array[idx]->value.choice.RICaction_Admitted_List;
2297 if(admitList->list.array != NULLP)
2299 for(listIdx=0 ; listIdx < admitList->list.count; listIdx++)
2301 DU_FREE(admitList->list.array[listIdx], sizeof(RICaction_Admitted_ItemIEs_t));
2303 DU_FREE(admitList->list.array, admitList->list.size);
2307 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
2309 notAdmitList = &ricSubscriptionRsp->protocolIEs.list.\
2310 array[idx]->value.choice.RICaction_NotAdmitted_List;
2311 if(notAdmitList->list.array != NULLP)
2313 for(listIdx=0 ; listIdx < notAdmitList->list.count; listIdx++)
2315 DU_FREE(notAdmitList->list.array[listIdx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
2317 DU_FREE(notAdmitList->list.array, notAdmitList->list.size);
2324 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], sizeof(RICsubscriptionResponse_IEs_t));
2327 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
2330 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2332 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
2336 /*******************************************************************
2338 * @brief Fill RIC Subscription Response IEs
2342 * Function : fillRicSubscriptionRsp
2344 * functionality: Fill RIC Subscription Response IEs
2346 * @param Pointer to RIC subscription response
2347 * Subscription response information
2348 * @return ROK - success
2351 ******************************************************************/
2352 uint8_t fillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp, PendingSubsRspInfo *subsRspInfo)
2355 uint8_t elementCnt = 0;
2356 RICsubscriptionResponse_IEs_t *subsRspIe = NULLP;
2359 if(subsRspInfo->numOfRejectedActions)
2362 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
2363 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
2364 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
2365 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
2367 DU_LOG("\nERROR --> E2AP : Memory allocation failed at %s : line %d", __func__, __LINE__);
2371 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
2373 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionResponse_IEs_t));
2374 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx] == NULLP)
2376 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d] : ieIdx [%d]", __func__, __LINE__,ieIdx);
2381 /* RIC Request ID */
2383 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2384 subsRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
2385 subsRspIe->criticality = CriticalityE2_reject;
2386 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
2387 subsRspIe->value.choice.RICrequestID.ricRequestorID = subsRspInfo->requestId.requestorId;
2388 subsRspIe->value.choice.RICrequestID.ricInstanceID = subsRspInfo->requestId.instanceId;
2390 /* RAN Function ID */
2392 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2393 subsRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
2394 subsRspIe->criticality = CriticalityE2_reject;
2395 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
2396 subsRspIe->value.choice.RANfunctionID = subsRspInfo->ranFuncId;
2398 /* RIC Action Admitted List */
2400 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2401 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_Admitted;
2402 subsRspIe->criticality = CriticalityE2_reject;
2403 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
2404 if(BuildRicActionAdmitList(&subsRspIe->value.choice.RICaction_Admitted_List, subsRspInfo) != ROK)
2406 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Admitted List in RIC Subscription Response");
2410 /* RIC Action Not Admitted List */
2411 if(subsRspInfo->numOfRejectedActions)
2414 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2415 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_NotAdmitted;
2416 subsRspIe->criticality = CriticalityE2_reject;
2417 subsRspIe->criticality = CriticalityE2_reject;
2418 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
2419 if(BuildRicActionNotAdmitList(&subsRspIe->value.choice.RICaction_NotAdmitted_List, subsRspInfo) != ROK)
2421 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Not Admitted List in RIC Subscription Response");
2429 /*******************************************************************
2431 * @brief Builds and Send the RicSubscriptionRsp
2435 * Function : BuildAndSendRicSubscriptionRsp
2437 * Functionality:Fills the RicSubscriptionRsp
2439 * @return ROK - success
2442 ******************************************************************/
2444 uint8_t BuildAndSendRicSubscriptionRsp(PendingSubsRspInfo *subsRspInfo)
2446 uint8_t ret = RFAILED;
2447 E2AP_PDU_t *e2apRicMsg = NULLP;
2448 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
2449 asn_enc_rval_t encRetVal;
2453 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
2455 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
2456 if(e2apRicMsg == NULLP)
2458 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2462 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
2463 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2464 if(e2apRicMsg->choice.successfulOutcome == NULLP)
2466 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
2470 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
2471 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2472 e2apRicMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
2474 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2476 if(fillRicSubscriptionRsp(ricSubscriptionRsp, subsRspInfo) != ROK)
2478 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
2482 /* Prints the Msg formed */
2483 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
2485 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2487 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
2488 if(encRetVal.encoded == ENCODE_FAIL)
2490 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
2491 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2496 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
2497 #ifdef DEBUG_ASN_PRINT
2498 for(int i=0; i< encBufSize; i++)
2500 printf("%x",encBuf[i]);
2505 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2507 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
2516 FreeRicSubscriptionRsp(e2apRicMsg);
2520 /******************************************************************
2522 * @brief Deallocation of memory allocated by aper decoder for e2 setup response
2526 * Function : freeAperDecodingOfE2SetupRsp
2528 * Functionality: Deallocation of memory allocated by aper decoder for e2
2531 * @params[in] E2setupResponse_t *e2SetRspMsg;
2534 * ****************************************************************/
2535 void freeAperDecodingOfE2SetupRsp(E2setupResponse_t *e2SetRspMsg)
2537 uint8_t arrIdx, e2NodeConfigAddAckListIdx;
2538 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
2539 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAddAckList;
2543 if(e2SetRspMsg->protocolIEs.list.array)
2545 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2547 if(e2SetRspMsg->protocolIEs.list.array[arrIdx])
2549 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2551 case ProtocolIE_IDE2_id_TransactionID:
2554 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2556 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.pLMN_Identity.buf);
2557 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID.buf);
2561 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2563 e2NodeConfigAddAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2564 if(e2NodeConfigAddAckList->list.array )
2566 for(e2NodeConfigAddAckListIdx = 0; e2NodeConfigAddAckListIdx< e2NodeConfigAddAckList->list.count; e2NodeConfigAddAckListIdx++)
2568 if(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx])
2570 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx];
2571 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2572 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf);
2573 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2574 e2nodeComponentInterfaceTypeF1);
2575 free(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx]);
2578 free(e2NodeConfigAddAckList->list.array);
2583 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]);
2586 free(e2SetRspMsg->protocolIEs.list.array);
2591 /******************************************************************
2593 * @brief handling of e2 noe config update ack ies
2597 * Function :handleE2NodeConfigUpdateAckIes
2599 * Functionality: handling of e2 noe config update ack ies
2602 * Pointer to the E2 Node cfg
2605 ******************************************************************/
2607 void handleE2NodeConfigUpdateAckIes(PTR e2NodeCfg, uint8_t procedureCode)
2609 CmLList *node=NULLP;
2610 E2NodeComponent *e2NodeComponentInfo=NULLP;
2611 E2nodeComponentID_t *e2nodeComponentID=NULLP;
2612 E2nodeComponentConfigRemovalAck_Item_t *removalAckItem=NULLP;
2613 E2nodeComponentConfigUpdateAck_Item_t *updateAckItem=NULLP;
2614 E2nodeComponentConfigAdditionAck_Item_t *additionAckItem=NULLP;
2616 switch(procedureCode)
2618 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2620 additionAckItem = (E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg;
2621 e2nodeComponentID = &additionAckItem->e2nodeComponentID;
2624 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
2626 updateAckItem = (E2nodeComponentConfigUpdateAck_Item_t*) e2NodeCfg;
2627 e2nodeComponentID = &updateAckItem->e2nodeComponentID;
2630 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
2632 removalAckItem= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
2633 e2nodeComponentID = &removalAckItem->e2nodeComponentID;
2638 switch(e2nodeComponentID->present)
2640 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
2642 e2NodeComponentInfo = fetchE2NodeComponentInfo(F1, e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0], &node);
2643 if(!e2NodeComponentInfo)
2645 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
2654 switch(procedureCode)
2656 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2658 DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, e2NodeComponentInfo->addConfiguration->reqBufSize);
2659 DU_FREE(e2NodeComponentInfo->addConfiguration->componentResponsePart, e2NodeComponentInfo->addConfiguration->rspBufSize);
2660 DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
2663 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
2665 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentRequestPart, e2NodeComponentInfo->updateConfiguration->reqBufSize);
2666 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentResponsePart, e2NodeComponentInfo->updateConfiguration->rspBufSize);
2667 DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
2670 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
2672 cmLListDelFrm(&duCb.e2apDb.e2NodeComponentList, node);
2673 if(e2NodeComponentInfo->addConfiguration)
2675 DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, e2NodeComponentInfo->addConfiguration->reqBufSize);
2676 DU_FREE(e2NodeComponentInfo->addConfiguration->componentResponsePart, e2NodeComponentInfo->addConfiguration->rspBufSize);
2677 DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
2679 if(e2NodeComponentInfo->updateConfiguration)
2681 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentRequestPart, e2NodeComponentInfo->updateConfiguration->reqBufSize);
2682 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentResponsePart, e2NodeComponentInfo->updateConfiguration->rspBufSize);
2683 DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
2685 DU_FREE(node, sizeof(CmLList));
2691 /******************************************************************
2693 * @brief Processes E2 Setup Response sent by RIC
2697 * Function : procE2SetupRsp
2699 * Functionality: Processes E2 Setup Response sent by RIC
2701 * @params[in] E2AP_PDU_t ASN decoded E2AP message
2704 * ****************************************************************/
2706 void procE2SetupRsp(E2AP_PDU_t *e2apMsg)
2708 bool invalidTransId = false;
2709 uint8_t arrIdx =0, idx=0;
2711 uint32_t recvBufLen;
2712 E2setupResponse_t *e2SetRspMsg=NULL;
2713 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
2714 RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL;
2715 RANfunctionsIDcause_List_t *ranFuncRejectedList=NULL;
2716 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
2717 E2nodeComponentConfigAdditionAck_List_t *e2NodeCfgAckList=NULL;
2718 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem=NULL;
2720 DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
2721 duCb.e2Status = TRUE; //Set E2 status as true
2722 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
2724 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2726 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2728 case ProtocolIE_IDE2_id_TransactionID:
2730 transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2731 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
2732 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
2734 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
2738 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
2739 invalidTransId = true;
2744 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2746 /* To store the Ric Id Params */
2747 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value\
2748 .choice.GlobalRIC_ID.pLMN_Identity.size);
2749 memcpy(&duCb.e2apDb.ricId.plmnId, e2SetRspMsg->protocolIEs.list.array[arrIdx]\
2750 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
2751 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID, &duCb.e2apDb.ricId);
2752 /*TODO : duCb.e2apDb.ricId.plmnId memory to be deallocated after the usage */
2756 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2758 e2NodeCfgAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2759 for(idx =0; idx <e2NodeCfgAckList->list.count; idx++)
2761 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeCfgAckList->list.array[idx];
2762 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
2763 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
2767 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2769 ranFuncAcceptedList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2770 for(idx =0; idx <ranFuncAcceptedList->list.count; idx++)
2772 ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[idx];
2773 DU_LOG("\nINFO --> E2AP : Ran function id [%ld] accepted",ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID);
2778 case ProtocolIE_IDE2_id_RANfunctionsRejected:
2780 ranFuncRejectedList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
2781 for(idx =0; idx <ranFuncRejectedList->list.count; idx++)
2783 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[idx];
2784 DU_LOG("\nINFO --> E2AP : Ran function id [%ld] rejected",ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID);
2790 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
2791 e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
2796 if(invalidTransId == true)
2801 freeAperDecodingOfE2SetupRsp(e2SetRspMsg);
2803 if(invalidTransId == false)
2805 if(duSendE2NodeConfigurationUpdate() != ROK)
2807 DU_LOG("\nERROR --> E2AP : Failed to send E2 node config update");
2812 /*******************************************************************
2814 * @brief Free RIC Subscription Request
2818 * Function : freeAperDecodingOfRicSubsReq
2820 * Functionality : Free RIC Subscription Request
2824 ******************************************************************/
2825 void freeAperDecodingOfRicSubsReq(RICsubscriptionRequest_t *ricSubscriptionReq)
2828 uint8_t elementIdx = 0;
2829 RICsubscriptionDetails_t *subsDetails = NULLP;
2830 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
2832 if(ricSubscriptionReq->protocolIEs.list.array)
2834 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
2836 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
2838 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
2840 subsDetails = &(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails);
2841 free(subsDetails->ricEventTriggerDefinition.buf);
2843 if(subsDetails->ricAction_ToBeSetup_List.list.array)
2845 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
2847 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
2849 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
2850 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
2852 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf);
2853 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition);
2855 free(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]);
2858 free(subsDetails->ricAction_ToBeSetup_List.list.array);
2863 free(ricSubscriptionReq->protocolIEs.list.array[idx]);
2865 free(ricSubscriptionReq->protocolIEs.list.array);
2869 /*******************************************************************
2871 * @brief Free Event Trigger Definition
2875 * Function : freeAperDecodingOfEventTriggerDef
2877 * Functionality: Free Event Trigger Definition
2879 * @params[in] E2SM-KPM Event Trigger Definition
2882 * ****************************************************************/
2883 void freeAperDecodingOfEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
2887 switch(eventTiggerDef->eventDefinition_formats.present)
2889 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
2892 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
2893 free(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1);
2899 /*******************************************************************
2901 * @brief Extract E2SM-KPM Event trigger definition
2905 * Function : extractEventTriggerDef
2907 * Functionality : This function :
2908 * - Decodes E2SM-KPM Event Trigger Definition
2909 * - Validates that even trigger style is supported by E2 node
2910 * - Stores event trigger details in local DB
2912 * @params[in] RAN Function Database structure
2913 * RIC Subscription Info to be added to RAN function
2914 * RIC Event Trigger Definition buffer received from RIC
2915 * @return ROK - success
2918 ******************************************************************/
2919 uint8_t extractEventTriggerDef(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
2920 RICeventTriggerDefinition_t *ricEventTriggerDef, E2FailureCause *failureCause)
2922 uint8_t ret = RFAILED;
2923 uint8_t eventIdx = 0;
2924 asn_dec_rval_t rval ={0};
2925 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef, *eventTiggerDefPtr = NULLP;
2927 /* Decoding E2SM-KPM Even Trigger Definition */
2928 eventTiggerDefPtr = &eventTiggerDef;
2929 memset(eventTiggerDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
2931 rval = aper_decode(0, &asn_DEF_E2SM_KPM_EventTriggerDefinition, (void **)&eventTiggerDefPtr, ricEventTriggerDef->buf,\
2932 ricEventTriggerDef->size, 0, 0);
2933 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2935 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Event Trigger Definition");
2936 failureCause->causeType = E2_PROTOCOL;
2937 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
2941 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, eventTiggerDefPtr);
2943 /* Validating the received event trigger definition format */
2944 for(eventIdx = 0; eventIdx < ranFuncDb->numOfEventTriggerStyleSupported; eventIdx++)
2946 if((eventTiggerDefPtr->eventDefinition_formats.present != \
2947 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING) && \
2948 (eventTiggerDefPtr->eventDefinition_formats.present == ranFuncDb->eventTriggerStyleList[eventIdx].formatType))
2950 ricSubscriptionInfo->eventTriggerDefinition.formatType = ranFuncDb->eventTriggerStyleList[eventIdx].formatType;
2951 ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod = \
2952 eventTiggerDefPtr->eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod;
2961 failureCause->causeType = E2_RIC_REQUEST;
2962 failureCause->cause = E2_EVENT_TRIGGER_NOT_SUPPORTED;
2964 /* Free E2SM_KPM_EventTriggerDefinition_t */
2965 freeAperDecodingOfEventTriggerDef(eventTiggerDefPtr);
2969 /*******************************************************************
2971 * @brief Free RIC Action Definition
2975 * Function : freeAperDecodingOfRicActionDefinition
2977 * Functionality: Free RIC Action Definition
2979 * @params[in] E2SM-KPM Action definition
2982 * ****************************************************************/
2983 void freeAperDecodingOfRicActionDefinition(E2SM_KPM_ActionDefinition_t *actionDef)
2985 uint8_t elementIdx = 0;
2986 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
2987 MeasurementInfoItem_t *measItem = NULLP;
2989 switch(actionDef->actionDefinition_formats.present)
2991 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
2993 if(actionDef->actionDefinition_formats.choice.actionDefinition_Format1)
2995 actionFormat1 = actionDef->actionDefinition_formats.choice.actionDefinition_Format1;
2996 if(actionFormat1->measInfoList.list.array)
2998 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
3000 if(actionFormat1->measInfoList.list.array[elementIdx])
3002 measItem = actionFormat1->measInfoList.list.array[elementIdx];
3003 switch(measItem->measType.present)
3005 case MeasurementType_PR_NOTHING:
3008 case MeasurementType_PR_measName:
3010 free(measItem->measType.choice.measName.buf);
3014 case MeasurementType_PR_measID:
3020 free(actionFormat1->measInfoList.list.array);
3022 free(actionFormat1);
3026 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
3027 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
3028 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
3029 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
3035 /*******************************************************************
3037 * @brief Extract Measurement Info list from action definition
3041 * Function : extractMeasInfoList
3043 * Functionality : This function :
3044 * - Traverses Measurement-to-be-subscribed list
3045 * - Validates that each measurement in Measurement-to-be-subscribed
3046 * list is supported in RAN-Function->Measurement-supported list.
3047 * - If all measurements in an action is supported by RAN function,
3048 * it is added to measurement-subscribed list in local DB
3050 * @params[in] Measurement Info supported list by RAN function
3051 * Measurement Info to be subscribed as requested by RIC
3052 * Measurement Info finally subscribed
3053 * Memory failure indicator
3054 * @return ROK - success
3057 ******************************************************************/
3058 uint8_t extractMeasInfoList(CmLListCp *measInfoSupportedList, MeasurementInfoList_t *measInfoToBeSubscribedList, \
3059 CmLListCp *measInfoSubscribedList, bool *memFailure)
3061 uint8_t elementIdx = 0;
3062 MeasurementInfoForAction *measInfoSupportedDb = NULLP;
3063 MeasurementInfo *measInfoSubscribedDb = NULLP;
3064 CmLList *supportedMeasNode = NULLP, *measToAddNode = NULLP;
3065 MeasurementInfoItem_t *measItem = NULLP;
3067 /* Validate Measurement list is supported by E2 node.
3069 * Traverse and compare the Measurement-Supported List in E2
3070 * node with Measurement-to-be-subscribed list received from RIC.
3071 * If a match is found, add it to measurement-subscription list.
3073 for(elementIdx = 0; elementIdx < measInfoToBeSubscribedList->list.count; elementIdx++)
3075 measInfoSubscribedDb = NULLP;
3076 measToAddNode = NULLP;
3077 measItem = measInfoToBeSubscribedList->list.array[elementIdx];
3079 CM_LLIST_FIRST_NODE(measInfoSupportedList, supportedMeasNode);
3080 while(supportedMeasNode)
3082 measInfoSupportedDb = (MeasurementInfoForAction*)supportedMeasNode->node;
3083 switch(measItem->measType.present)
3085 case MeasurementType_PR_measName:
3087 if(!strcmp(measInfoSupportedDb->measurementTypeName, (char *)measItem->measType.choice.measName.buf))
3089 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
3094 case MeasurementType_PR_measID:
3096 if(measInfoSupportedDb->measurementTypeId == measItem->measType.choice.measID)
3098 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
3105 DU_LOG("\nERROR -> DUAPP: Invalid Measurement-type identifier in \
3106 E2SM-KPM Action Definition Format");
3109 } /* End of switch, for measurement type identifier */
3111 /* If measurement type is supported, add to measurement-subscription list */
3112 if(measInfoSubscribedDb)
3114 measInfoSubscribedDb->measurementTypeId = measInfoSupportedDb->measurementTypeId;
3115 memcpy(measInfoSubscribedDb->measurementTypeName, measInfoSupportedDb->measurementTypeName, \
3116 strlen(measInfoSupportedDb->measurementTypeName));
3118 DU_ALLOC(measToAddNode, sizeof(CmLList));
3121 measToAddNode->node = (PTR) measInfoSubscribedDb;
3122 cmLListAdd2Tail(measInfoSubscribedList, measToAddNode);
3124 /* Break out of while loop if measurement info is found in measurement-supported list */
3129 DU_FREE(measInfoSubscribedDb, sizeof(MeasurementInfo));
3130 measInfoSubscribedDb = NULLP;
3136 supportedMeasNode = supportedMeasNode->next;
3138 } /* End of while for traversing measurement-supported list in a report style */
3140 /* If a measurement-to-be-subscribed is not found in measurement-supported list in this report style
3142 * Delete all entries from measurement-subscription list and
3143 * Break out of for loop to search in next report style */
3144 if(!measInfoSubscribedDb)
3146 deleteMeasurementInfoList(measInfoSubscribedList);
3150 } /* End of for loop , traversing measurement-to-be-subscribed list */
3152 /* If all measurement-to-be-subscribed was found in measurement-supported list and
3153 * was added to measurement-subscription list successfully, return from here */
3154 if(measInfoToBeSubscribedList->list.count == measInfoSubscribedList->count)
3160 /*******************************************************************
3162 * @brief Extract E2SM-KPM Action definition
3166 * Function : extractRicActionDef
3168 * Functionality : This function :
3169 * - Decodes E2SM-KPM Action Definition
3170 * - Validates that action is supported by E2 node
3171 * - Stores action details in local DB
3173 * @params[in] RAN Function Database structure
3174 * RIC subscription's Action definition to be added to
3176 * RIC Action Definition buffer received from RIC
3177 * @return ROK - success
3180 ******************************************************************/
3181 uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefDb, RICactionDefinition_t *ricActionDef,\
3182 E2FailureCause *failureCause)
3184 bool memFailure = false;
3185 uint8_t styleIdx = 0;
3186 asn_dec_rval_t rval ={0};
3188 E2SM_KPM_ActionDefinition_t actionDef, *actionDefPtr = NULLP;
3189 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
3190 CmLListCp *measInfoSupportedList = NULLP;
3191 CmLListCp *measInfoSubscribedList = NULLP;
3193 /* Decoding E2SM-KPM Action Definition */
3194 actionDefPtr = &actionDef;
3195 memset(actionDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
3197 rval = aper_decode(0, &asn_DEF_E2SM_KPM_ActionDefinition, (void **)&actionDefPtr, ricActionDef->buf,\
3198 ricActionDef->size, 0, 0);
3199 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
3201 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Action Definition");
3202 failureCause->causeType = E2_PROTOCOL;
3203 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
3207 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDefPtr);
3210 /* Validate if Report style to subscribe is supported by E2 Node */
3211 for(styleIdx= 0; styleIdx < ranFuncDb->numOfReportStyleSupported; styleIdx++)
3213 /* Validate Report style type and report style format type is supported by E2 Node */
3214 if((ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType == actionDefPtr->ric_Style_Type) &&
3215 (ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType == actionDefPtr->actionDefinition_formats.present))
3217 /* Fetch Report stype type and format type */
3218 actionDefDb->styleType = actionDefPtr->ric_Style_Type;
3219 actionDefDb->formatType = actionDefPtr->actionDefinition_formats.present;
3221 switch(actionDefPtr->actionDefinition_formats.present)
3223 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
3225 actionFormat1 = actionDefPtr->actionDefinition_formats.choice.actionDefinition_Format1;
3227 /* Fetch granularity period */
3228 actionDefDb->choice.format1.granularityPeriod = actionFormat1->granulPeriod;
3230 /* Validate and add the Measurement to subscription list */
3231 measInfoSupportedList = &ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
3232 measInfoSubscribedList = &actionDefDb->choice.format1.measurementInfoList;
3233 if(extractMeasInfoList(measInfoSupportedList, &actionFormat1->measInfoList, \
3234 measInfoSubscribedList, &memFailure) == ROK)
3238 /* Free E2SM_KPM_ActionDefinition_t */
3239 freeAperDecodingOfRicActionDefinition(actionDefPtr);
3244 break; /* End of E2SM-KPM Action definition format 1 case */
3249 DU_LOG("\nERROR -> DUAPP: Only E2SM-KPM Action Definition Format 1 is supported");
3252 } /* End of switch for E2SM-KPM Action definition formats */
3257 failureCause->causeType = E2_MISCELLANEOUS;
3258 failureCause->cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3261 } /* End of for loop, traversing Report-styles-supported list in E2 node */
3263 /* Memset action Db and Free E2SM_KPM_ActionDefinition_t */
3264 memset(actionDefDb, 0, sizeof(ActionDefinition));
3265 freeAperDecodingOfRicActionDefinition(actionDefPtr);
3267 if(failureCause->causeType == E2_NOTHING)
3269 failureCause->causeType = E2_RIC_REQUEST;
3270 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3275 /*******************************************************************
3277 * @brief add RIC Subs action info
3281 * Function : addRicSubsAction
3283 * Functionality: add Ric Subs action info
3287 * Pointer to Ric Subc info
3288 * Action Sequence list
3291 * @return ROK - success
3294 ******************************************************************/
3296 CmLList *addRicSubsAction(RanFunction *ranFuncDb, PTR ricSubsInfo, CmLListCp *actionSequence, uint8_t procedureCode, E2FailureCause *failureCause)
3298 CmLList *actionNode = NULLP;
3299 ActionInfo *actionDb = NULLP;
3300 RICactionID_t ricActionID;
3301 RICactionType_t ricActionType;
3302 RICactionDefinition_t *ricActionDefinition= NULLP;
3303 RICaction_ToBeSetup_Item_t *setupItem= NULLP;
3304 RICaction_ToBeAddedForModification_Item_t *addIem= NULLP;
3305 RICaction_ToBeModifiedForModification_Item_t *modifiedItem= NULLP;
3307 switch(procedureCode)
3309 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
3311 setupItem = (RICaction_ToBeSetup_Item_t *)ricSubsInfo;
3312 ricActionID= setupItem->ricActionID;
3313 ricActionType= setupItem->ricActionType;
3314 if(setupItem->ricActionDefinition)
3316 ricActionDefinition = setupItem->ricActionDefinition;
3320 case ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item:
3322 addIem = (RICaction_ToBeAddedForModification_Item_t*) ricSubsInfo;
3323 ricActionID= addIem->ricActionID;
3324 ricActionType= addIem->ricActionType;
3325 ricActionDefinition = &addIem->ricActionDefinition;
3329 case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item:
3331 modifiedItem= (RICaction_ToBeModifiedForModification_Item_t*)ricSubsInfo;
3332 ricActionID= modifiedItem->ricActionID;
3333 /* Added since ricActionType IE is not present in case of
3335 ricActionType = RICactionType_report;
3336 if(modifiedItem->ricActionDefinition)
3338 ricActionDefinition = modifiedItem->ricActionDefinition;
3345 DU_ALLOC(actionDb, sizeof(ActionInfo));
3348 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
3351 if(ricActionType== RICactionType_report)
3353 actionDb->actionId = ricActionID;
3354 actionDb->type = REPORT;
3356 if(extractRicActionDef(ranFuncDb, &actionDb->definition, ricActionDefinition, failureCause) == ROK)
3358 actionDb->action = CONFIG_ADD;
3361 DU_ALLOC(actionNode, sizeof(CmLList));
3364 actionNode->node = (PTR) actionDb;
3365 cmLListAdd2Tail(actionSequence, actionNode);
3369 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
3370 DU_FREE(actionDb, sizeof(ActionInfo));
3377 /*******************************************************************
3379 * @brief Extract RIC Action to be setup
3383 * Function : extractRicActionToBeSetup
3385 * Functionality : This function :
3386 * - Validates that each action-to-be-setup is supported by E2 node
3387 * - Stores event trigger details in local DB
3389 * @params[in] RAN Function Database structure
3390 * RIC Subscription Info to be added to RAN function
3391 * RIC Action To Be Setup List received from RIC
3392 * @return ROK - success
3395 ******************************************************************/
3396 uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
3397 RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause, PendingSubsRspInfo *subsRsp)
3399 CmLList *actionNode = NULLP;
3400 uint8_t actionIdx = 0;
3401 uint8_t ricActionId = 0;
3402 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
3404 if(actionList->list.array)
3406 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
3408 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)actionList->list.array[actionIdx];
3409 switch(actionItem->id)
3411 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
3413 /* If Action type is REPORT and
3414 * If RIC action definition's extraction and validation passes,
3416 * This action is added to action sequence list of subscription info */
3417 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeSetup_Item,\
3418 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item, failureCause);
3422 /* In case of any failure, action is rejected
3423 * Added to rejected-action-list in subscription response */
3424 subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId;
3425 if(failureCause->causeType == E2_NOTHING)
3427 failureCause->causeType = E2_RIC_REQUEST;
3428 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
3430 memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \
3431 failureCause, sizeof(E2FailureCause));
3432 subsRsp->numOfRejectedActions++;
3437 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
3443 /* If there is even 1 action that can be added, return ROK */
3444 if(ricSubscriptionInfo->actionSequence.count)
3447 if(failureCause->causeType == E2_NOTHING)
3449 failureCause->causeType = E2_RIC_REQUEST;
3450 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3455 /******************************************************************
3457 * @brief Processes RIC Subscription Req sent by RIC
3461 * Function : procRicSubscriptionRequest
3463 * Functionality: Processes RIC Subscription Request from RIC
3465 * @params[in] E2AP_PDU_t ASN decoded E2AP message
3466 * @return ROK - success
3469 * ****************************************************************/
3470 uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg)
3474 uint16_t ranFuncId = 0;
3475 RicRequestId ricReqId;
3476 CmLList *ricSubscriptionNode = NULLP;
3477 RanFunction *ranFuncDb = NULLP;
3478 RICsubscriptionRequest_t *ricSubsReq = NULLP;
3479 RICsubscriptionDetails_t *subsDetails = NULLP;
3480 RicSubscription *ricSubscriptionInfo = NULLP;
3481 E2FailureCause failureCause;
3483 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
3485 memset(&failureCause, 0, sizeof(E2FailureCause));
3486 memset(&ricReqId, 0, sizeof(RicRequestId));
3488 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
3489 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
3491 if(ricSubsReq->protocolIEs.list.array[idx])
3493 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
3495 case ProtocolIE_IDE2_id_RICrequestID:
3497 ricReqId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID;
3498 ricReqId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID;
3503 case ProtocolIE_IDE2_id_RANfunctionID:
3505 ranFuncId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID;
3507 /* Validating RAN Function id */
3508 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
3512 failureCause.causeType = E2_RIC_REQUEST;
3513 failureCause.cause = E2_RAN_FUNCTION_ID_INVALID;
3518 if(ranFuncDb->numPendingSubsRsp >= MAX_PENDING_SUBSCRIPTION_RSP)
3520 failureCause.causeType = E2_RIC_REQUEST;
3521 failureCause.cause = E2_FUNCTION_RESOURCE_LIMIT;
3526 DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription));
3527 if(!ricSubscriptionInfo)
3529 DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
3530 failureCause.causeType = E2_MISCELLANEOUS;
3531 failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3535 ricSubscriptionInfo->requestId.requestorId = ricReqId.requestorId;
3536 ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId;
3537 ricSubscriptionInfo->ranFuncId = ranFuncId;
3539 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3540 memcpy(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].requestId,
3541 &ricReqId, sizeof(RicRequestId));
3542 ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].ranFuncId = ranFuncId;
3546 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
3548 subsDetails = &ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails;
3550 /* Decode, Validate and record Event Trigger Definition */
3551 if(extractEventTriggerDef(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricEventTriggerDefinition, \
3552 &failureCause) != ROK)
3558 /* Decode, Validate and record RIC actions */
3559 if(extractRicActionToBeSetup(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricAction_ToBeSetup_List, \
3560 &failureCause, &ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp]) != ROK)
3569 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
3570 ricSubsReq->protocolIEs.list.array[idx]->id);
3579 freeAperDecodingOfRicSubsReq(ricSubsReq);
3583 cmInitTimers(&(ricSubscriptionInfo->ricSubsReportTimer), 1);
3584 ricSubscriptionInfo->action = CONFIG_ADD;
3586 /* Add RAN subcription detail to RAN function */
3587 DU_ALLOC(ricSubscriptionNode, sizeof(CmLList));
3588 if(ricSubscriptionNode)
3590 ricSubscriptionNode->node = (PTR) ricSubscriptionInfo;
3591 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubscriptionNode);
3594 ranFuncDb->numPendingSubsRsp++;
3596 /* Send statistics request to other DU entities */
3597 BuildAndSendStatsReq(ricSubscriptionInfo);
3601 DU_FREE(ricSubscriptionInfo, sizeof(RicSubscription));
3605 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3608 /* Send RIC Subcription Failure */
3609 BuildAndSendRicSubscriptionFailure(ricReqId, ranFuncId, failureCause);
3614 /******************************************************************
3616 * @brief Free RIC Subscription Failure
3620 * Function : FreeRicSubscriptionFailure
3622 * Functionality: Free RIC Subscription Failure
3624 * @params[in] E2AP PDU
3627 * ****************************************************************/
3628 void FreeRicSubscriptionFailure(E2AP_PDU_t *e2apMsg)
3630 uint8_t elemIdx = 0;
3631 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3635 if(e2apMsg->choice.unsuccessfulOutcome)
3637 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3638 if(ricSubscriptionFailure->protocolIEs.list.array)
3640 for(elemIdx = 0; elemIdx < ricSubscriptionFailure->protocolIEs.list.count; elemIdx++)
3642 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3644 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3646 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3648 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3652 /******************************************************************
3654 * @brief Fill and Send RIC Subscription Failure to RIC
3658 * Function : BuildAndSendRicSubscriptionFailure
3660 * Functionality: Fill and Send RIC Subscription Failure to RIC
3662 * @params[in] RIC Request ID
3665 * @return ROK - success
3668 * ****************************************************************/
3669 uint8_t BuildAndSendRicSubscriptionFailure(RicRequestId ricReqId, uint16_t ranFuncId, E2FailureCause failureCause)
3671 uint8_t ret = RFAILED;
3672 uint8_t elementCnt = 0, elemIdx = 0;
3673 E2AP_PDU_t *e2apMsg = NULLP;
3674 asn_enc_rval_t encRetVal; /* Encoder return value */
3675 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3676 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3680 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Failure\n");
3682 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3683 if(e2apMsg == NULLP)
3685 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3689 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3690 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3691 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3693 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3696 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
3697 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3698 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure;
3700 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3703 ricSubscriptionFailure->protocolIEs.list.count = elementCnt;
3704 ricSubscriptionFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionFailure_IEs_t *);
3705 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3706 if(!ricSubscriptionFailure->protocolIEs.list.array)
3708 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3712 for(elemIdx = 0; elemIdx < elementCnt; elemIdx++)
3714 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3715 if(!ricSubscriptionFailure->protocolIEs.list.array[elemIdx])
3717 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d] for IE at index [%d]", \
3718 __func__, __LINE__, elemIdx);
3722 if(elemIdx < elementCnt)
3727 /* RIC Request ID */
3728 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3729 ricSubsFailIe->id = ProtocolIE_IDE2_id_RICrequestID;
3730 ricSubsFailIe->criticality = CriticalityE2_reject;
3731 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
3732 ricSubsFailIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3733 ricSubsFailIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3735 /* RAN Function ID */
3736 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3737 ricSubsFailIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3738 ricSubsFailIe->criticality = CriticalityE2_reject;
3739 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
3740 ricSubsFailIe->value.choice.RANfunctionID = ranFuncId;
3743 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3744 ricSubsFailIe->id = ProtocolIE_IDE2_id_CauseE2;
3745 ricSubsFailIe->criticality = CriticalityE2_reject;
3746 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_CauseE2;
3747 fillE2Cause(&ricSubsFailIe->value.choice.CauseE2, failureCause);
3749 /* Prints the Msg formed */
3750 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3751 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3753 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3754 if(encRetVal.encoded == ENCODE_FAIL)
3756 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Failure Message (at %s)\n",\
3757 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3762 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Failure Message \n");
3763 #ifdef DEBUG_ASN_PRINT
3764 for(int i=0; i< encBufSize; i++)
3766 printf("%x",encBuf[i]);
3771 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
3773 DU_LOG("\nINFO --> E2AP : Sending RIC Subscription Failure");
3779 FreeRicSubscriptionFailure(e2apMsg);
3783 /*******************************************************************
3785 * @brief Free the RicIndication Message
3789 * Function : FreeRicIndication
3791 * Functionality: Free the RicIndication Message
3796 ******************************************************************/
3797 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
3800 RICindication_t *ricIndicationMsg= NULLP;
3802 if(e2apMsg != NULLP)
3804 if(e2apMsg->choice.initiatingMessage != NULLP)
3806 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
3807 if(ricIndicationMsg!= NULLP)
3809 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
3811 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
3813 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
3815 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
3817 case ProtocolIE_IDE2_id_RICrequestID:
3818 case ProtocolIE_IDE2_id_RANfunctionID:
3819 case ProtocolIE_IDE2_id_RICactionID:
3820 case ProtocolIE_IDE2_id_RICindicationType:
3823 case ProtocolIE_IDE2_id_RICindicationHeader:
3825 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
3826 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
3829 case ProtocolIE_IDE2_id_RICindicationMessage:
3831 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
3832 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
3838 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
3841 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
3844 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3846 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3850 /*******************************************************************
3852 * @brief Free measurement record
3856 * Function : freeMeasRecord
3858 * Functionality: Free all measurement recorded for a measurement
3859 * within an action in a RIC subscription
3861 * @param Measurement data to be freed
3864 ******************************************************************/
3865 void freeMeasData(MeasurementData_t *measData)
3867 uint8_t measIdx = 0, measRecIdx = 0;
3868 MeasurementRecord_t *measRecord = NULLP;
3870 if(measData->list.array)
3872 for(measIdx = 0; measIdx < measData->list.count; measIdx++)
3874 if(measData->list.array[measIdx])
3876 measRecord = &measData->list.array[measIdx]->measRecord;
3877 if(measRecord->list.array)
3879 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3881 DU_FREE(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3883 DU_FREE(measRecord->list.array, measRecord->list.size);
3885 DU_FREE(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
3888 DU_FREE(measData->list.array, measData->list.size);
3892 /*******************************************************************
3894 * @brief Fill measurement info list
3898 * Function : freeMeasInfoList
3900 * Functionality: Fills all measurement info within an action
3901 * in a RIC subscription
3903 * @param Measurement Info list to be freed
3906 ******************************************************************/
3907 void freeMeasInfoList(MeasurementInfoList_t *measInfoList)
3909 uint8_t measInfoIdx = 0;
3911 if(measInfoList->list.array)
3913 for(measInfoIdx = 0; measInfoIdx < measInfoList->list.count; measInfoIdx++)
3915 if(measInfoList->list.array[measInfoIdx])
3917 DU_FREE(measInfoList->list.array[measInfoIdx]->measType.choice.measName.buf, \
3918 measInfoList->list.array[measInfoIdx]->measType.choice.measName.size);
3920 DU_FREE(measInfoList->list.array[measInfoIdx], measInfoList->list.size);
3923 DU_FREE(measInfoList->list.array, measInfoList->list.size);
3927 /*******************************************************************
3929 * @brief Free E2SM-KPM Indication Message
3933 * Function : FreeE2smKpmIndicationMessage
3935 * Functionality: Free E2SM-KPM Indication Message
3937 * @param E2SM-KPM Indication message to be freed
3940 ******************************************************************/
3941 void FreeE2smKpmIndicationMessage(E2SM_KPM_IndicationMessage_t *e2smKpmIndMsg)
3943 E2SM_KPM_IndicationMessage_Format1_t *format1Msg = NULLP;
3945 switch(e2smKpmIndMsg->indicationMessage_formats.present)
3947 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
3949 if(e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1)
3951 format1Msg = e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1;
3953 /* Measurement Data */
3954 freeMeasData(&format1Msg->measData);
3956 /* Measurement Info List */
3957 if(format1Msg->measInfoList)
3959 freeMeasInfoList(format1Msg->measInfoList);
3960 DU_FREE(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
3963 /* Granularity Period */
3964 DU_FREE(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
3966 DU_FREE(format1Msg, sizeof(E2SM_KPM_IndicationMessage_Format1_t));
3971 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
3972 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
3978 /*******************************************************************
3980 * @brief Fill measurement record
3984 * Function : fillMeasRecord
3986 * Functionality: Fills all measurement value for a measurement
3987 * within an action in a RIC subscription
3989 * @param Measurement record to be filled
3990 * Measurement database with measurement records
3991 * @return ROK - success
3994 ******************************************************************/
3995 uint8_t fillMeasRecord(MeasurementRecord_t *measRecord, MeasurementInfo *measInfoDb)
3997 uint8_t measRecIdx = 0;
3998 CmLList *measValNode = NULLP;
4001 measRecord->list.count = measInfoDb->measuredValue.count;
4002 measRecord->list.size = measRecord->list.count * sizeof(MeasurementRecordItem_t *);
4004 DU_ALLOC(measRecord->list.array, measRecord->list.size);
4005 if(!measRecord->list.array)
4007 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4011 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
4013 DU_ALLOC(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
4014 if(!measRecord->list.array[measRecIdx])
4016 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4022 CM_LLIST_FIRST_NODE(&measInfoDb->measuredValue, measValNode);
4025 measVal = *(double *)measValNode->node;
4026 if(measVal == (int)measVal)
4028 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_integer;
4029 measRecord->list.array[measRecIdx]->choice.integer = (int)measVal;
4033 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_real;
4034 measRecord->list.array[measRecIdx]->choice.real = measVal;
4037 measValNode= measValNode->next;
4038 /* Once the measurement record is added to the message, delete it from DB */
4041 deleteMeasuredValueList(&measInfoDb->measuredValue);
4045 /*******************************************************************
4047 * @brief Fills measuerement data
4051 * Function : fillMeasData
4053 * Functionality: Fill all measurement recorded for all measurements
4054 * in an action in a RIC subscription
4056 * @param Measurement data to be filled
4057 * Measurement info list from an action DB
4058 * @return ROK - success
4061 ******************************************************************/
4062 uint8_t fillMeasData(MeasurementData_t *measData, CmLListCp *measInfoListDb)
4064 uint8_t measIdx = 0;
4065 CmLList *measInfoNode = NULLP;
4066 MeasurementInfo *measInfoDb = NULLP;
4067 MeasurementRecord_t *measRecord = NULLP;
4069 measData->list.count = measInfoListDb->count;
4070 measData->list.size = measData->list.count * sizeof(MeasurementDataItem_t *);
4072 DU_ALLOC(measData->list.array, measData->list.size);
4073 if(!measData->list.array)
4075 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4080 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4083 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4086 DU_ALLOC(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
4087 if(!measData->list.array[measIdx])
4089 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4093 measRecord = &measData->list.array[measIdx]->measRecord;
4094 if(fillMeasRecord(measRecord, measInfoDb) != ROK)
4096 DU_LOG("\nERROR --> E2AP : Failed to fill measurement record");
4101 measInfoNode = measInfoNode->next;
4107 /*******************************************************************
4109 * @brief Fill all measurement info
4113 * Function : fillMeasInfoList
4115 * Functionality: Fills all measurement info belonging to an action
4116 * in a RIC subscription
4118 * @param Measurement Info list to be filled
4119 * Measurement Info list from E2AP DB
4120 * @return ROK - success
4123 ******************************************************************/
4124 uint8_t fillMeasInfoList(MeasurementInfoList_t *measInfoList, CmLListCp *measInfoListDb)
4126 uint8_t measInfoIdx = 0;
4127 CmLList *measInfoNode = NULLP;
4128 MeasurementInfo *measInfoDb = NULLP;
4129 MeasurementInfoItem_t *measInfoItem = NULLP;
4131 measInfoList->list.count = measInfoListDb->count;
4132 measInfoList->list.size = measInfoList->list.count * sizeof(MeasurementInfoItem_t *);
4134 DU_ALLOC(measInfoList->list.array, measInfoList->list.size);
4135 if(!measInfoList->list.array)
4137 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4142 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4145 DU_ALLOC(measInfoList->list.array[measInfoIdx], sizeof(MeasurementInfoItem_t));
4146 if(!measInfoList->list.array[measInfoIdx])
4148 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4152 measInfoItem = measInfoList->list.array[measInfoIdx];
4153 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4156 /* Measurement Type */
4157 measInfoItem->measType.present = MeasurementType_PR_measName;
4158 measInfoItem->measType.choice.measName.size = strlen(measInfoDb->measurementTypeName);
4160 DU_ALLOC(measInfoItem->measType.choice.measName.buf, measInfoItem->measType.choice.measName.size);
4161 if(!measInfoItem->measType.choice.measName.buf)
4163 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4167 memcpy(measInfoItem->measType.choice.measName.buf, measInfoDb->measurementTypeName,\
4168 measInfoItem->measType.choice.measName.size);
4172 measInfoNode = measInfoNode->next;
4179 /*******************************************************************
4181 * @brief Fill E2SM-KPM Indication Message Format 1
4185 * Function : fillE2smKpmIndMsgFormat1
4187 * Functionality: Fill E2SM-KPM Indication Message Format 1
4189 * @param Format 1 Message to be filled
4190 * Action Definition format 1 from E2AP DB
4191 * @return ROK - success
4194 ******************************************************************/
4195 uint8_t fillE2smKpmIndMsgFormat1(E2SM_KPM_IndicationMessage_Format1_t *format1Msg, ActionDefFormat1 *format1)
4197 /* Measurement Data */
4198 if(fillMeasData(&format1Msg->measData, &format1->measurementInfoList) != ROK)
4200 DU_LOG("\nERROR --> E2AP : Failed to fill measurement data");
4204 /* Measurement Information */
4205 DU_ALLOC(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
4206 if(!format1Msg->measInfoList)
4208 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4212 if(fillMeasInfoList(format1Msg->measInfoList, &format1->measurementInfoList) != ROK)
4214 DU_LOG("\nERROR --> E2AP : Failed to fill measurement information list");
4218 /* Granularity Period */
4219 DU_ALLOC(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
4220 if(!format1Msg->granulPeriod)
4222 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4225 *(format1Msg->granulPeriod) = format1->granularityPeriod;
4230 /*******************************************************************
4232 * @brief Fill RIC Indication Message buffer
4236 * Function : fillRicIndMsgBuf
4238 * Functionality: Fill E2SM-KPM Indication Message
4239 * Encode this message and copy to RIC Indication Message buffer
4241 * @param RIC Indication Message buffer to be filled
4242 * Source action info from E2AP DB
4243 * @return ROK - success
4246 ******************************************************************/
4247 uint8_t fillRicIndMsgBuf(RICindicationMessage_t *ricIndMsgBuf, ActionInfo *actionInfo)
4249 uint8_t ret = RFAILED;
4250 bool failedInFormat = false;
4251 E2SM_KPM_IndicationMessage_t e2smKpmIndMsg;
4252 asn_enc_rval_t encRetVal; /* Encoder return value */
4254 memset(&e2smKpmIndMsg, 0, sizeof(E2SM_KPM_IndicationMessage_t));
4258 /* E2SM-KPM Indication message format type */
4259 e2smKpmIndMsg.indicationMessage_formats.present = actionInfo->definition.formatType;
4260 switch(e2smKpmIndMsg.indicationMessage_formats.present)
4262 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
4264 /* E2SM-KPM Indication message format 1 */
4265 DU_ALLOC(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4266 sizeof(E2SM_KPM_IndicationMessage_Format1_t));
4267 if(!e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1)
4269 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4270 failedInFormat = true;
4274 if(fillE2smKpmIndMsgFormat1(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4275 &actionInfo->definition.choice.format1) != ROK)
4277 DU_LOG("\nERROR --> E2AP : Failed to fill E2SM-KPM Indication message format 1");
4278 failedInFormat = true;
4284 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
4285 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
4288 DU_LOG("\nERROR --> E2AP : fillRicIndMsgBuf: Only Format 1 supported");
4289 failedInFormat = true;
4297 /* Encode E2SM-KPM Indication Message */
4298 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationMessage, &e2smKpmIndMsg);
4299 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4301 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationMessage, 0, &e2smKpmIndMsg, PrepFinalEncBuf, encBuf);
4302 if(encRetVal.encoded == ENCODE_FAIL)
4304 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Message (at %s)\n",\
4305 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4310 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Message \n");
4311 #ifdef DEBUG_ASN_PRINT
4312 for(int i=0; i< encBufSize; i++)
4314 printf("%x",encBuf[i]);
4319 /* Copy encoded string to RIC Indication Message buffer */
4320 ricIndMsgBuf->size = encBufSize;
4321 DU_ALLOC(ricIndMsgBuf->buf, ricIndMsgBuf->size);
4322 if(!ricIndMsgBuf->buf)
4324 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4327 memset(ricIndMsgBuf->buf, 0, ricIndMsgBuf->size);
4328 memcpy(ricIndMsgBuf->buf, encBuf, encBufSize);
4334 /* Free E2SM-KPM Indication Message */
4335 FreeE2smKpmIndicationMessage(&e2smKpmIndMsg);
4340 /*******************************************************************
4342 * @brief Free E2SM-KPM Indication Header
4346 * Function : FreeE2smKpmIndicationHeader
4348 * Functionality: Free E2SM-KPM Indication Header
4350 * @param E2SM-KPM Indication Header to be free
4353 ******************************************************************/
4354 void FreeE2smKpmIndicationHeader(E2SM_KPM_IndicationHeader_t *e2smKpmIndHdr)
4356 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4360 switch(e2smKpmIndHdr->indicationHeader_formats.present)
4362 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4364 if(e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1)
4366 format1 = e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1;
4368 DU_FREE(format1->colletStartTime.buf, format1->colletStartTime.size);
4369 DU_FREE(format1, sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4373 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4380 /*******************************************************************
4382 * @brief Fill RIC Indication Header buffer
4386 * Function : fillRicIndHeader
4388 * Functionality: Fill E2SM-KPM Indication Header
4389 * Encode this message and copy to RIC Indication Header buffer
4391 * @param RIC Indication Header buffer to be filled
4392 * Source RIC subscription info from E2AP DB
4393 * @return ROK - success
4396 ******************************************************************/
4397 uint8_t fillRicIndHeader(RICindicationHeader_t *ricIndHdr, RicSubscription *ricSubsInfo)
4399 uint8_t ret = RFAILED;
4400 uint8_t secBufIdx = 0, milliSecBufIdx = 0;
4402 bool formatFailure = false;
4403 RanFunction *ranFunc = NULLP;
4404 ReportStartTime *startTime = NULLP;
4405 E2SM_KPM_IndicationHeader_t e2smKpmIndHdr;
4406 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4407 asn_enc_rval_t encRetVal; /* Encoder return value */
4411 ranFunc = fetchRanFuncFromRanFuncId(ricSubsInfo->ranFuncId);
4412 if(ranFunc == NULLP)
4414 DU_LOG("\nERROR --> E2AP : RAN Function ID [%d] not found", ricSubsInfo->ranFuncId);
4418 memset(&e2smKpmIndHdr, 0, sizeof(E2SM_KPM_IndicationHeader_t));
4420 e2smKpmIndHdr.indicationHeader_formats.present = ranFunc->ricIndicationHeaderFormat;
4421 switch(e2smKpmIndHdr.indicationHeader_formats.present)
4423 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4425 DU_ALLOC(e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1, \
4426 sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4427 if(!e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1)
4429 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4430 formatFailure = true;
4433 format1 = e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1;
4435 /* Fetch reporting period start time from DB */
4436 switch(ricSubsInfo->eventTriggerDefinition.formatType)
4440 startTime = &ricSubsInfo->eventTriggerDefinition.choice.format1.startTime;
4444 format1->colletStartTime.size = 8 * sizeof(uint8_t);
4445 DU_ALLOC(format1->colletStartTime.buf, format1->colletStartTime.size);
4446 if(!format1->colletStartTime.buf)
4448 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4449 formatFailure = true;
4453 /* As per O-RAN.WG3.E2SM-KPM-R003-v03.00, section 8.3.12 and
4454 * RFC 5905, section 6 :
4455 * Time stamp has a 64-bit format where first 32-bit is seconds
4456 * and next 32-bit is fraction in picosecond-level.
4457 * This fraction has been rounded in microseconds.
4460 * Storing 32-bit seconds at MSB 0-3 and
4461 * 32-bit milliseconds at next 4 bytes i.e. bytes 4-7
4465 for(byteIdx = 3; byteIdx >= 0; byteIdx--)
4467 format1->colletStartTime.buf[secBufIdx++] = startTime->timeInSec >> (8*byteIdx);
4468 format1->colletStartTime.buf[milliSecBufIdx++] = startTime->timeInMilliSec >> (8*byteIdx);
4473 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4476 DU_LOG("\nERROR --> E2AP : Only E2SM-KPM Indication Header Format 1 supported");
4477 formatFailure = true;
4485 /* Encode E2SM-KPM Indication Header */
4486 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationHeader, &e2smKpmIndHdr);
4487 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4489 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationHeader, 0, &e2smKpmIndHdr, PrepFinalEncBuf, encBuf);
4490 if(encRetVal.encoded == ENCODE_FAIL)
4492 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Header (at %s)\n",\
4493 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4498 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Header \n");
4499 #ifdef DEBUG_ASN_PRINT
4500 for(int i=0; i< encBufSize; i++)
4502 printf("%x",encBuf[i]);
4507 /* Copy encoded string to RIC Indication Header buffer */
4508 ricIndHdr->size = encBufSize;
4509 DU_ALLOC(ricIndHdr->buf, ricIndHdr->size);
4512 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4515 memset(ricIndHdr->buf, 0, ricIndHdr->size);
4516 memcpy(ricIndHdr->buf, encBuf, encBufSize);
4521 /* Free E2SM-KPM Indication Header */
4522 FreeE2smKpmIndicationHeader(&e2smKpmIndHdr);
4527 /*******************************************************************
4529 * brief Fill the RIC Indication Message
4533 * Function : fillRicIndication
4535 * Functionality: Fills the RIC Indication Message
4537 * @param RIC Indication Message to be filled
4538 * RIC Subscription DB
4540 * @return ROK - success
4543 ******************************************************************/
4544 uint8_t fillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4546 uint8_t elementCnt = 0, idx = 0;
4551 ricIndicationMsg->protocolIEs.list.count = elementCnt;
4552 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_IEs_t *);
4554 /* Initialize the Ric Indication members */
4555 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, ricIndicationMsg->protocolIEs.list.size);
4556 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
4558 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4562 for(idx=0; idx<elementCnt; idx++)
4564 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx], sizeof(RICindication_IEs_t));
4565 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
4567 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4572 /* RIC Request ID */
4574 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
4575 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4576 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICrequestID;
4577 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = \
4578 ricSubscriptionInfo->requestId.requestorId;
4579 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = \
4580 ricSubscriptionInfo->requestId.instanceId;
4582 /* RAN Function ID */
4584 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
4585 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4586 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RANfunctionID;
4587 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ricSubscriptionInfo->ranFuncId;
4591 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
4592 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4593 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICactionID;
4594 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = actionInfo->actionId;
4596 /* RIC Indication Type */
4598 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
4599 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4600 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationType;
4601 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = actionInfo->type;
4603 /* RIC Indication Header */
4605 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
4606 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4607 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationHeader;
4608 if(fillRicIndHeader(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader, \
4609 ricSubscriptionInfo) != ROK)
4611 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication header");
4615 /* RIC Indication Message */
4617 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
4618 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4619 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationMessage;
4620 if(fillRicIndMsgBuf(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage, \
4623 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication Message");
4630 /*******************************************************************
4632 * @brief Builds and Send the RicIndication Message
4636 * Function : BuildAndSendRicIndication
4638 * Functionality:Fills the RicIndication Message
4640 * @return ROK - success
4643 ******************************************************************/
4645 uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4647 uint8_t ret = RFAILED;
4648 E2AP_PDU_t *e2apMsg = NULLP;
4649 RICindication_t *ricIndicationMsg = NULLP;
4650 asn_enc_rval_t encRetVal; /* Encoder return value */
4654 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
4656 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4657 if(e2apMsg == NULLP)
4659 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4663 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4664 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4665 if(e2apMsg->choice.initiatingMessage == NULLP)
4667 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4670 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
4671 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4672 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
4674 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
4676 if(fillRicIndication(ricIndicationMsg, ricSubscriptionInfo, actionInfo) != ROK)
4678 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication message");
4682 /* Prints the Msg formed */
4683 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4684 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4686 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4688 if(encRetVal.encoded == ENCODE_FAIL)
4690 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
4691 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4696 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
4697 #ifdef DEBUG_ASN_PRINT
4698 for(int i=0; i< encBufSize; i++)
4700 printf("%x",encBuf[i]);
4705 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
4707 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
4713 FreeRicIndication(e2apMsg);
4717 /*******************************************************************
4719 * @brief free e2 node component configuration req and rsp
4723 * Function : freeE2NodeComponentConfiguration
4726 * - free e2 node component configuration req and rsp
4728 * @params[in] E2nodeComponentConfiguration_t *e2nodeComponentConfiguration
4729 * @return ROK - success
4732 * ****************************************************************/
4734 void freeE2NodeComponentConfiguration(E2nodeComponentConfiguration_t *e2nodeComponentConfiguration)
4736 /* Free E2 Node Component Request Part */
4737 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentRequestPart.buf, e2nodeComponentConfiguration->e2nodeComponentRequestPart.size);
4739 /* Free E2 Node Component Response Part */
4740 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentResponsePart.buf, e2nodeComponentConfiguration->e2nodeComponentResponsePart.size);
4744 /*******************************************************************
4746 * @brief free e2 node component component identifier
4750 * Function : freeE2NodeComponentIdentifier
4753 * - free e2 node component component identifier
4755 * @params[in] E2nodeComponentID_t *componentID
4756 * @return ROK - success
4759 * ****************************************************************/
4761 void freeE2NodeComponentIdentifier(E2nodeComponentID_t *componentID)
4763 if(componentID->choice.e2nodeComponentInterfaceTypeF1)
4765 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
4766 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
4771 /*******************************************************************
4773 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
4777 * Function : FreeE2NodeConfigUpdate
4780 * - freeing the memory allocated for E2nodeConfigurationUpdate
4782 * @params[in] E2AP_PDU_t *e2apMsg
4783 * @return ROK - success
4786 * ****************************************************************/
4788 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
4790 uint8_t arrIdx =0, e2NodeUpdateListIdx=0, e2NodeRemovalListIdx=0, e2NodeAddListIdx=0;
4791 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate =NULL;
4792 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList =NULL;
4793 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItem =NULL;
4794 E2nodeComponentConfigRemoval_List_t *e2NodeRemovalList =NULL;
4795 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItem =NULL;
4796 E2nodeComponentConfigAddition_List_t *e2NodeAddList =NULL;
4797 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem =NULL;
4799 if(e2apMsg != NULLP)
4801 if(e2apMsg->choice.initiatingMessage != NULLP)
4803 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4804 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
4806 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
4808 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx])
4811 switch(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id)
4813 case ProtocolIE_IDE2_id_TransactionID:
4816 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
4818 e2NodeAddList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
4819 if(e2NodeAddList->list.array)
4821 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
4823 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
4825 freeE2NodeComponentConfiguration(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration);
4826 freeE2NodeComponentIdentifier(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID);
4827 DU_FREE(e2NodeAddItem, sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
4829 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
4833 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
4835 e2NodeUpdateList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List;
4836 if(e2NodeUpdateList->list.array)
4838 for(e2NodeUpdateListIdx = 0; e2NodeUpdateListIdx< e2NodeUpdateList->list.count; e2NodeUpdateListIdx++)
4840 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[e2NodeUpdateListIdx];
4842 freeE2NodeComponentConfiguration(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentConfiguration);
4843 freeE2NodeComponentIdentifier(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentID);
4844 DU_FREE(e2NodeUpdateItem, sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
4846 DU_FREE(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
4850 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
4852 e2NodeRemovalList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List;
4853 if(e2NodeRemovalList->list.array)
4855 for(e2NodeRemovalListIdx = 0; e2NodeRemovalListIdx< e2NodeRemovalList->list.count; e2NodeRemovalListIdx++)
4857 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemovalList->list.array[e2NodeRemovalListIdx];
4859 freeE2NodeComponentIdentifier(&e2NodeRemovalItem->value.choice.E2nodeComponentConfigRemoval_Item.e2nodeComponentID);
4860 DU_FREE(e2NodeRemovalItem, sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
4862 DU_FREE(e2NodeRemovalList->list.array, e2NodeRemovalList->list.size);
4870 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4873 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4875 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4877 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4881 /*******************************************************************
4883 * @brief Buld and send the E2 node config update msg
4887 * Function : BuildAndSendE2NodeConfigUpdate
4890 * - Buld and send the E2 node config update msg
4893 * @return ROK - success
4896 * ****************************************************************/
4898 uint8_t BuildAndSendE2NodeConfigUpdate(E2NodeConfigList *e2NodeList)
4900 uint8_t ret = RFAILED;
4901 uint8_t arrIdx = 0,elementCnt = 0;
4903 E2AP_PDU_t *e2apMsg = NULLP;
4904 asn_enc_rval_t encRetVal; /* Encoder return value */
4905 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
4907 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
4910 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4911 if(e2apMsg == NULLP)
4913 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4917 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4918 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4919 if(e2apMsg->choice.initiatingMessage == NULLP)
4921 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4924 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4925 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
4926 e2apMsg->choice.initiatingMessage->value.present = \
4927 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
4928 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4931 if(e2NodeList->addE2NodeCount)
4933 if(e2NodeList->updateE2NodeCount)
4935 if(e2NodeList->removeE2NodeCount)
4938 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
4939 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
4940 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4941 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
4943 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4947 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
4949 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4950 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
4953 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4958 if(arrIdx<elementCnt)
4962 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4963 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4964 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
4965 transId = assignTransactionId();
4966 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4968 if(e2NodeList->addE2NodeCount)
4971 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
4972 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4973 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigAddition_List;
4974 if(BuildE2NodeConfigAddList(&(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List),\
4975 ProcedureCodeE2_id_E2nodeConfigurationUpdate, e2NodeList->addE2NodeCount, e2NodeList->addE2Node)!=ROK)
4977 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
4982 if(e2NodeList->updateE2NodeCount)
4985 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate;
4986 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4987 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigUpdate_List;
4988 if(BuildE2NodeConfigUpdateList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List,\
4989 e2NodeList->updateE2NodeCount, e2NodeList->updateE2Node) != ROK)
4992 DU_LOG("\nERROR --> E2AP : Failed to update the E2 node configuration");
4997 if(e2NodeList->removeE2NodeCount)
5000 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval;
5001 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5002 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigRemoval_List;
5003 if(BuildE2NodeConfigRemoveList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List,\
5004 e2NodeList->removeE2NodeCount, e2NodeList->removeE2Node) != ROK)
5007 DU_LOG("\nERROR --> E2AP : Failed to remove the E2 node configuration");
5012 /* Prints the Msg formed */
5013 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5015 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5017 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5018 if(encRetVal.encoded == ENCODE_FAIL)
5020 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
5021 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5026 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
5027 #ifdef DEBUG_ASN_PRINT
5028 for(int i=0; i< encBufSize; i++)
5030 printf("%x",encBuf[i]);
5034 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
5036 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
5040 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5041 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5042 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.e2NodeConfigUpdate.configList, e2NodeList, sizeof(E2NodeConfigList));
5047 FreeE2NodeConfigUpdate(e2apMsg);
5051 /*******************************************************************
5053 * @brief Deallocate the memory allocated for E2ResetRequest msg
5057 * Function : FreeE2ResetRequest
5060 * - freeing the memory allocated for E2ResetRequest
5062 * @params[in] E2AP_PDU_t *e2apMsg
5063 * @return ROK - success
5066 * ****************************************************************/
5067 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
5070 ResetRequestE2_t *resetReq = NULLP;
5072 if(e2apMsg != NULLP)
5074 if(e2apMsg->choice.initiatingMessage != NULLP)
5076 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5077 if(resetReq->protocolIEs.list.array)
5079 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
5081 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5083 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5085 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5087 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5091 /*******************************************************************
5093 * @brief Build and send the E2 reset request msg
5097 * Function : BuildAndSendE2ResetRequest
5100 * - Buld and send the E2 reset request msg to RIC
5104 * @return ROK - success
5107 * ****************************************************************/
5108 uint8_t BuildAndSendE2ResetRequest(E2FailureCause resetCause)
5110 uint8_t ieIdx = 0, elementCnt = 0;
5111 uint16_t transId = 0;
5112 uint8_t ret = RFAILED;
5113 E2AP_PDU_t *e2apMsg = NULLP;
5114 ResetRequestE2_t *resetReq = NULLP;
5115 asn_enc_rval_t encRetVal; /* Encoder return value */
5117 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
5121 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5122 if(e2apMsg == NULLP)
5124 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
5128 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5129 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5130 if(e2apMsg->choice.initiatingMessage == NULLP)
5132 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
5136 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
5137 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5138 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
5139 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5142 resetReq->protocolIEs.list.count = elementCnt;
5143 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
5145 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5146 if(!resetReq->protocolIEs.list.array)
5148 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5149 Reset Request IE array");
5153 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5155 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5156 if(!resetReq->protocolIEs.list.array[ieIdx])
5158 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5159 Reset Request IE array element");
5164 /* In case of failure */
5165 if(ieIdx < elementCnt)
5169 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5170 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
5171 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
5172 transId = assignTransactionId();
5173 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
5176 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
5177 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
5178 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
5179 fillE2Cause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, resetCause);
5181 /* Prints the Msg formed */
5182 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5184 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5186 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
5188 if(encRetVal.encoded == ENCODE_FAIL)
5190 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
5191 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5196 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
5197 #ifdef DEBUG_ASN_PRINT
5198 for(int i=0; i< encBufSize; i++)
5200 printf("%x",encBuf[i]);
5204 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5206 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5210 /* In case the message is sent successfully, store the transaction info to
5211 * be used when response is received */
5212 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5213 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5219 /* Free all memory */
5220 FreeE2ResetRequest(e2apMsg);
5224 /*******************************************************************
5226 * @brief Deallocate the memory allocated for Reset Response msg
5230 * Function : freeAperDecodingOfE2ResetRsp
5233 * - freeing the memory allocated for Reset response
5235 * @params[in] ResetResponseE2_t *resetResponse
5238 * ****************************************************************/
5239 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
5245 if(resetResponse->protocolIEs.list.array)
5247 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5249 if(resetResponse->protocolIEs.list.array[ieIdx])
5251 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5253 case ProtocolIE_IDE2_id_TransactionID:
5256 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5259 free(resetResponse->protocolIEs.list.array[ieIdx]);
5262 free(resetResponse->protocolIEs.list.array);
5267 /******************************************************************
5269 * @brief Processes E2 Reset Response sent by RIC
5273 * Function : procResetResponse
5275 * Functionality: Processes E2 Reset Response sent by RIC
5277 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5280 * ****************************************************************/
5281 void procResetResponse(E2AP_PDU_t *e2apMsg)
5283 bool invalidTransId=false;
5285 uint16_t transId =0;
5286 uint16_t ranFuncIdx=0;
5287 ResetResponseE2_t *resetResponse =NULLP;
5289 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
5290 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
5292 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5294 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5296 case ProtocolIE_IDE2_id_TransactionID:
5298 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5299 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \
5300 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
5302 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5306 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5307 invalidTransId = true;
5311 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5313 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
5315 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
5317 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
5318 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
5325 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
5326 resetResponse->protocolIEs.list.array[ieIdx]->id);
5331 if(invalidTransId == true)
5337 freeAperDecodingOfE2ResetRsp(resetResponse);
5340 /******************************************************************
5342 * @brief Deallocation of memory allocated by aper decoder for e2 setup Failure
5346 * Function : freeAperDecodingOfE2SetupFailure
5348 * Functionality: Deallocation of memory allocated by aper decoder for e2
5351 * @params[in] E2setupFailure_t *e2SetupFailure;
5354 * ****************************************************************/
5355 void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure)
5361 if(e2SetupFailure->protocolIEs.list.array)
5363 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5365 if(e2SetupFailure->protocolIEs.list.array[arrIdx])
5367 free(e2SetupFailure->protocolIEs.list.array[arrIdx]);
5370 free(e2SetupFailure->protocolIEs.list.array);
5374 /******************************************************************
5376 * @brief Processes E2 Setup Failure sent by RIC
5380 * Function : procE2SetupFailure
5382 * Functionality: Processes E2 Setup failure sent by RIC
5384 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5385 * @return ROK - success
5388 * ****************************************************************/
5389 void procE2SetupFailure(E2AP_PDU_t *e2apMsg)
5391 uint16_t transId =0;
5392 uint8_t arrIdx =0, timerValue=0;
5393 E2setupFailure_t *e2SetupFailure;
5395 DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
5396 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
5398 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5400 switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id)
5402 case ProtocolIE_IDE2_id_TransactionID:
5404 transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5405 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
5406 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5408 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5412 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5417 case ProtocolIE_IDE2_id_TimeToWaitE2:
5419 timerValue = convertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
5420 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE)
5422 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue);
5426 DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
5434 freeAperDecodingOfE2SetupFailure(e2SetupFailure);
5436 /******************************************************************
5438 * @brief Deallocation of memory allocated by aper decoder for RIC service Query
5442 * Function : freeAperDecodingOfRicServiceQuery
5444 * Functionality: Deallocation of memory allocated by aper decoder for RIC
5447 * @params[in] RICserviceQuery_t *ricServiceQuery;
5450 * ****************************************************************/
5452 void freeAperDecodingOfRicServiceQuery(RICserviceQuery_t *ricServiceQuery)
5454 uint8_t arrIdx,ranFuncIdx;
5455 RANfunctionsID_List_t *ranFuncAddedList;
5459 if(ricServiceQuery->protocolIEs.list.array)
5461 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5463 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
5465 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5467 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5469 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5470 if(ranFuncAddedList->list.array)
5472 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5474 free(ranFuncAddedList->list.array[ranFuncIdx]);
5476 free(ranFuncAddedList->list.array);;
5483 free(ricServiceQuery->protocolIEs.list.array[arrIdx]);
5486 free(ricServiceQuery->protocolIEs.list.array);
5490 /*******************************************************************
5492 * @brief Build RanFunction Delete List
5496 * Function : BuildRanFunctionDeleteList
5498 * Functionality: Build RanFunction Delete List
5501 * RANfunctionsID List
5502 * Count of the RAN function
5503 * Received RAN function list
5505 * @return ROK - success
5508 ******************************************************************/
5510 uint8_t BuildRanFunctionDeleteList(RANfunctionsID_List_t *deleteList, uint8_t count, RanFuncInfo *recvdRanFunc)
5512 uint8_t ranFuncIdx=0;
5513 RANfunctionID_ItemIEs_t *delRanFuncItem;
5517 deleteList->list.count = count;
5518 deleteList->list.size = deleteList->list.count * sizeof(RANfunctionID_ItemIEs_t*);
5519 DU_ALLOC(deleteList->list.array, deleteList->list.size);
5520 if(deleteList->list.array == NULLP)
5522 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5525 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
5527 DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t));
5528 if(deleteList->list.array[ranFuncIdx] == NULLP)
5530 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5533 delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx];
5534 delRanFuncItem->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
5535 delRanFuncItem->criticality = CriticalityE2_ignore;
5536 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionID = recvdRanFunc[ranFuncIdx].id;
5537 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionRevision = recvdRanFunc[ranFuncIdx].revisionCounter;
5543 /*******************************************************************
5545 * @brief De Allocate Ric Service Update message
5549 * Function : FreeRicServiceUpdate
5551 * Functionality: De-Allocating Ric Service Update message
5553 * @params[in] E2AP_PDU_t *e2apMsg
5557 * ****************************************************************/
5559 void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg)
5562 uint8_t ranFuncAddListIdx=0, ranFuncDelIdx=0;
5563 RICserviceUpdate_t *ricServiceUpdate;
5564 RANfunctions_List_t *ranFunctionsList;
5565 RANfunction_ItemIEs_t *ranFuncItemIe;
5566 RANfunction_Item_t *ranFunItem;
5567 RANfunctionsID_List_t *deleteList;
5569 /* De-allocating Memory */
5570 if(e2apMsg != NULLP)
5572 if(e2apMsg->choice.initiatingMessage != NULLP)
5574 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5575 if(ricServiceUpdate->protocolIEs.list.array != NULLP)
5577 for(arrIdx = 0; arrIdx < ricServiceUpdate->protocolIEs.list.count; arrIdx++)
5579 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] != NULLP)
5581 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
5583 case ProtocolIE_IDE2_id_TransactionID:
5586 case ProtocolIE_IDE2_id_RANfunctionsAdded:
5587 case ProtocolIE_IDE2_id_RANfunctionsModified:
5589 ranFunctionsList = &(ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
5590 if(ranFunctionsList->list.array)
5592 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
5594 if(ranFunctionsList->list.array[ranFuncAddListIdx])
5596 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
5597 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
5598 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
5599 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
5600 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
5603 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
5607 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
5609 deleteList= &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5610 if(deleteList->list.array)
5612 for(ranFuncDelIdx = 0; ranFuncDelIdx< deleteList->list.count; ranFuncDelIdx++)
5614 DU_FREE(deleteList->list.array[ranFuncDelIdx], sizeof(RANfunctionID_ItemIEs_t));
5616 DU_FREE(deleteList->list.array, deleteList->list.size);
5622 DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
5623 (ricServiceUpdate->protocolIEs.list.array[arrIdx]->id));
5626 DU_FREE(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5629 DU_FREE(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5631 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5633 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5637 /*******************************************************************
5639 * @brief Builds and Send the RicServiceUpdateuest
5643 * Function : BuildAndSendRicServiceUpdate
5645 * Functionality:Fills the RicServiceUpdateuest
5647 * @return ROK - success
5650 ******************************************************************/
5652 uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate)
5654 uint16_t transId = 0;
5655 bool memAllocFailed =false;
5656 uint8_t arrIdx = 0, elementCnt=0,ret = RFAILED;
5657 E2AP_PDU_t *e2apMsg = NULLP;
5658 RICserviceUpdate_t *ricServiceUpdate = NULLP;
5659 asn_enc_rval_t encRetVal; /* Encoder return value */
5661 DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n");
5664 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5665 if(e2apMsg == NULLP)
5667 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5670 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5671 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5672 if(e2apMsg->choice.initiatingMessage == NULLP)
5674 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5677 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5678 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
5679 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceUpdate;
5680 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5682 /* For TransId IE, set elementCnt to 1.
5683 If there is any item in the RAN function add list, RAN function modification list, or RAN function delete list, increment the elementCnt.*/
5686 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5688 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5690 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5693 ricServiceUpdate->protocolIEs.list.count = elementCnt;
5694 ricServiceUpdate->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdate_IEs_t*);
5696 /* Initialize the E2Setup members */
5697 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5698 if(ricServiceUpdate->protocolIEs.list.array == NULLP)
5700 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
5704 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
5706 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5707 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP)
5709 memAllocFailed = true;
5710 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
5714 if(memAllocFailed == true)
5720 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5721 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5722 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
5723 if(serviceUpdate.dir == E2_NODE_INITIATED)
5724 transId = assignTransactionId();
5726 transId = serviceUpdate.transId;
5727 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5729 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5732 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
5733 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5734 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5735 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,\
5736 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded, serviceUpdate.recvRanFuncList.ranFunToBeAdded) !=ROK)
5742 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5745 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsModified;
5746 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5747 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5748 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,
5749 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeModified, serviceUpdate.recvRanFuncList.ranFunToBeModified) !=ROK)
5755 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5758 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsDeleted;
5759 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5760 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctionsID_List;
5761 if(BuildRanFunctionDeleteList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List,\
5762 serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted, serviceUpdate.recvRanFuncList.ranFunToBeDeleted) != ROK)
5767 /* Prints the Msg formed */
5768 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5770 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5772 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5773 if(encRetVal.encoded == ENCODE_FAIL)
5775 DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
5776 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5781 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
5782 #ifdef DEBUG_ASN_PRINT
5783 for(int i=0; i< encBufSize; i++)
5785 printf("%x",encBuf[i]);
5789 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5791 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5800 if(serviceUpdate.dir == E2_NODE_INITIATED)
5802 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5803 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5807 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId = transId;
5808 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5810 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.dir = serviceUpdate.dir;
5811 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.transId =transId;
5812 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.recvRanFuncList, &serviceUpdate.recvRanFuncList, sizeof(E2TmpRanFunList));
5814 FreeRicServiceUpdate(e2apMsg);
5817 /******************************************************************
5819 * @brief Processes RIC service Query sent by RIC
5823 * Function : procRicServiceQuery
5825 * Functionality: Processes RIC service Query sent by RIC
5827 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5828 * @return ROK - success
5831 * ****************************************************************/
5833 void procRicServiceQuery(E2AP_PDU_t *e2apMsg)
5836 uint16_t arrIdx =0, ranFuncIdx=0,tmpIdx=0;
5837 uint16_t id,revisionCcounter;
5838 bool tmpArray[MAX_RAN_FUNCTION] = {false};
5839 RICserviceQuery_t *ricServiceQuery=NULL;
5840 RicServiceUpdate ricUpdate;
5841 RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
5842 RANfunctionsID_List_t *ranFuncAddedList;
5844 DU_LOG("\nINFO --> E2AP : RIC Service Query received");
5845 memset(&ricUpdate, 0, sizeof(RicServiceUpdate));
5846 ricUpdate.dir = RIC_INITIATED;
5847 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
5849 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5851 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5853 /* TODO completing in next patch/gerrit */
5854 case ProtocolIE_IDE2_id_TransactionID:
5856 ricUpdate.transId = ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5860 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5862 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5863 if(ranFuncAddedList->list.array)
5865 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5867 if(ranFuncAddedList->list.array[ranFuncIdx])
5869 /* Using the RAN function Id, identify the RAN function to be modified or deleted. */
5871 ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
5872 id = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID;
5873 revisionCcounter = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision;
5875 if((id != duCb.e2apDb.ranFunction[id-1].id))
5877 action = CONFIG_DEL;
5879 else if((id == duCb.e2apDb.ranFunction[id-1].id)&&(revisionCcounter!=duCb.e2apDb.ranFunction[id-1].revisionCounter))
5881 action = CONFIG_MOD;
5884 if(action == CONFIG_DEL)
5886 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].id = id;
5887 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].revisionCounter = revisionCcounter;
5888 ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted++;
5890 else if(action == CONFIG_MOD)
5892 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].id = id;
5893 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].revisionCounter = revisionCcounter;
5894 ricUpdate.recvRanFuncList.numOfRanFunToBeModified++;
5897 /* If any ID is set to true, it means that the ID has been used in either modification or deletion list.
5898 * Else we will add the IDs into the added list */
5899 tmpArray[id-1] = true;
5908 /* Traversing the whole RAN function list in ducb to check if any new Ran function ids have been added. */
5909 for(arrIdx =0; arrIdx<MAX_RAN_FUNCTION; arrIdx++)
5911 tmpIdx= ricUpdate.recvRanFuncList.numOfRanFunToBeAdded;
5912 if((duCb.e2apDb.ranFunction[arrIdx].id >0)&&(!tmpArray[arrIdx]))
5914 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[arrIdx].id;
5915 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[arrIdx].revisionCounter;
5916 ricUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
5920 if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK)
5922 DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message");
5925 freeAperDecodingOfRicServiceQuery(ricServiceQuery);
5928 /******************************************************************
5930 * @brief Deallocation of memory allocated by aper decoder for
5931 * RIC service update ack
5935 * Function : freeAperDecodingOfRicServiceUpdateAck
5937 * Functionality: Deallocation of memory allocated by aper decoder
5938 * for RIC service update ack
5940 * @params[in] RICserviceUpdateAck_t *ricServiceAck;
5943 * ****************************************************************/
5945 void freeAperDecodingOfRicServiceUpdateAck(RICserviceUpdateAcknowledge_t *ricServiceAck)
5947 uint8_t arrIdx=0,ranFuncIdx=0;
5948 RANfunctionsID_List_t *ranFuncAddedList=NULL;
5952 if(ricServiceAck->protocolIEs.list.array)
5954 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5956 if(ricServiceAck->protocolIEs.list.array[arrIdx])
5958 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5960 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5962 ranFuncAddedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5963 if(ranFuncAddedList->list.array)
5965 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5967 free(ranFuncAddedList->list.array[ranFuncIdx]);
5969 free(ranFuncAddedList->list.array);
5976 free(ricServiceAck->protocolIEs.list.array[arrIdx]);
5979 free(ricServiceAck->protocolIEs.list.array);
5984 /******************************************************************
5986 * @brief Processes RIC service update ack sent by RIC
5990 * Function : procRicServiceUpdateAck
5992 * Functionality: Processes RIC service update ack sent by RIC
5994 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5995 * @return ROK - success
5998 * ****************************************************************/
6000 void procRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
6003 uint16_t transId =0;
6004 uint16_t id =0, tmpIdx=0, ranFuncIdx=0;
6005 RicServiceUpdate serviceUpdate;
6006 RANfunctionsIDcause_List_t *rejectedList=NULL;
6007 RICserviceUpdateAcknowledge_t *ricServiceAck=NULL;
6008 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
6010 DU_LOG("\nINFO --> E2AP : RIC service update ack received");
6011 memset(&serviceUpdate, 0, sizeof(RicServiceUpdate));
6012 ricServiceAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
6014 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
6016 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
6018 case ProtocolIE_IDE2_id_TransactionID:
6020 transId = ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
6021 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
6022 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
6024 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
6026 else if((duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId == transId) &&\
6027 (duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
6029 memset(&duCb.e2apDb.e2TransInfo.ricInitTransaction[transId], 0, sizeof(E2TransInfo));
6033 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
6039 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
6042 case ProtocolIE_IDE2_id_RANfunctionsRejected:
6044 rejectedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
6045 if(rejectedList->list.array)
6047 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
6049 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)rejectedList->list.array[ranFuncIdx];
6050 id = ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID;
6051 tmpIdx= serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded;
6052 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[id-1].id;
6053 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[id-1].revisionCounter;
6054 serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
6063 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
6065 serviceUpdate.dir = E2_NODE_INITIATED;
6066 BuildAndSendRicServiceUpdate(serviceUpdate);
6068 freeAperDecodingOfRicServiceUpdateAck(ricServiceAck);
6071 /******************************************************************
6073 * @brief Deallocation of memory allocated by aper decoder for
6074 * RIC service update failure
6078 * Function : freeAperDecodingOfRicServiceUpdateFailure
6080 * Functionality: Deallocation of memory allocated by aper decoder
6081 * for RIC service update failure
6083 * @params[in] RICserviceUpdateFailure_t *ricServiceFailure;
6086 * ****************************************************************/
6088 void freeAperDecodingOfRicServiceUpdateFailure(RICserviceUpdateFailure_t *ricServiceFailure)
6092 if(ricServiceFailure)
6094 if(ricServiceFailure->protocolIEs.list.array)
6096 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6098 if(ricServiceFailure->protocolIEs.list.array[arrIdx])
6100 free(ricServiceFailure->protocolIEs.list.array[arrIdx]);
6103 free(ricServiceFailure->protocolIEs.list.array);
6108 /******************************************************************
6110 * @brief Processes RIC service update failure sent by RIC
6114 * Function : procRicServiceUpdateFailure
6116 * Functionality: Processes RIC service update failure sent by RIC
6118 * @params[in] E2AP_PDU_t ASN decoded E2AP message
6119 * @return ROK - success
6122 * ****************************************************************/
6124 void procRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
6126 uint8_t arrIdx =0, timerValue=0;
6127 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
6129 DU_LOG("\nINFO --> E2AP : RIC service update failure received");
6130 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
6132 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6134 switch(ricServiceFailure->protocolIEs.list.array[arrIdx]->id)
6136 case ProtocolIE_IDE2_id_TransactionID:
6140 case ProtocolIE_IDE2_id_TimeToWaitE2:
6142 timerValue = convertE2WaitTimerEnumToValue(ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
6143 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR)) == FALSE)
6145 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR, timerValue);
6149 DU_LOG("\nERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running");
6154 case ProtocolIE_IDE2_id_CauseE2:
6161 freeAperDecodingOfRicServiceUpdateFailure(ricServiceFailure);
6164 /******************************************************************
6166 * @brief DU Send E2 Node Configuration Update
6170 * Function : duSendE2NodeConfigurationUpdate
6172 * Functionality: DU Send E2 Node Configuration Update
6174 * @return ROK - success
6177 * ****************************************************************/
6179 uint8_t duSendE2NodeConfigurationUpdate()
6181 E2NodeConfigList e2NodeList;
6182 CmLList *node =NULL;
6183 E2NodeComponent *e2NodeComponentInfo=NULL;
6185 memset(&e2NodeList, 0, sizeof(E2NodeConfigList));
6186 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
6189 e2NodeComponentInfo = (E2NodeComponent*)node->node;
6191 if(e2NodeComponentInfo->addConfiguration)
6193 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6194 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6195 e2NodeList.addE2NodeCount++;
6198 if(e2NodeComponentInfo->updateConfiguration)
6200 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6201 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6202 e2NodeList.updateE2NodeCount++;
6205 if(e2NodeComponentInfo->deleteConfiguration == true)
6207 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6208 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].componentId = e2NodeComponentInfo->componentId;
6209 e2NodeList.removeE2NodeCount++;
6215 if(BuildAndSendE2NodeConfigUpdate(&e2NodeList) !=ROK)
6217 DU_LOG("\nERROR --> E2AP : Failed to build and send e2 node config update message to RIC_stub");
6223 /*******************************************************************
6225 * @brief Free RIC Subscription Modification Required
6229 * Function : FreeRicSubsModRequired
6231 * Functionality: Freqq RIC Subscription Modification required
6233 * @param E2AP Message PDU to be freed
6236 ******************************************************************/
6237 void FreeRicSubsModRequired(E2AP_PDU_t *e2apMsg)
6239 uint8_t ieIdx = 0, arrIdx = 0;
6240 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6241 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6242 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6243 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6247 if(e2apMsg->choice.initiatingMessage)
6249 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6250 if(ricSubsModReqd->protocolIEs.list.array)
6252 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
6254 if(ricSubsModReqd->protocolIEs.list.array[ieIdx])
6256 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6257 switch(ricSubsModReqdIe->id)
6259 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
6261 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6262 if(actionToBeModList->list.array)
6264 for(arrIdx = 0; arrIdx < actionToBeModList->list.count; arrIdx++)
6266 DU_FREE(actionToBeModList->list.array[arrIdx], \
6267 sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6269 DU_FREE(actionToBeModList->list.array, actionToBeModList->list.size);
6274 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
6276 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6277 if(actionToBeRmvList->list.array)
6279 for(arrIdx = 0; arrIdx < actionToBeRmvList->list.count; arrIdx++)
6281 DU_FREE(actionToBeRmvList->list.array[arrIdx], \
6282 sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6284 DU_FREE(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6292 DU_FREE(ricSubsModReqd->protocolIEs.list.array[ieIdx], \
6293 sizeof(RICsubscriptionModificationRequired_IEs_t));
6296 DU_FREE(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6298 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6300 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6304 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6305 * However, E2SM-KPM supports only RIC Report service.
6306 * Hence there is no subsequent action in RIC subscription that may require modification.
6307 * So commenting the action-modification IEs for the time being
6310 /*******************************************************************
6312 * @brief Fill Action required to be modified list
6316 * Function : FillActionReqdToBeModList
6318 * Functionality: Fill Action required to be modified list
6320 * @param RIC Actions Required To Be Modified List to be filled
6321 * Number of actions to be modified
6322 * RIC Subscription DB
6323 * @return ROK - success
6326 ******************************************************************/
6327 uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod,\
6328 RicSubscription *ricSubscription)
6331 CmLList *actionNode = NULLP;
6332 ActionInfo *actionDb = NULLP;
6333 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL;
6335 actionToBeModList->list.count = numActionsMod;
6336 actionToBeModList->list.size = numActionsMod * sizeof(RICaction_RequiredToBeModified_ItemIEs_t *);
6337 DU_ALLOC(actionToBeModList->list.array, actionToBeModList->list.size);
6338 if(!actionToBeModList->list.array)
6340 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6345 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6348 actionDb = (ActionInfo*)(actionNode->node);
6349 if(actionDb->action == CONFIG_MOD)
6351 DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6352 if(!actionToBeModList->list.array[arrIdx])
6354 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6357 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[arrIdx];
6359 actionToBeMod->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeModified_Item;
6360 actionToBeMod->criticality = CriticalityE2_reject;
6361 actionToBeMod->value.present = \
6362 RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item;
6363 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \
6365 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms;
6374 /*******************************************************************
6376 * @brief Fill Action required to be removed list
6380 * Function : FillActionReqdToBeRmvList
6382 * Functionality: Fill Action required to be removed list
6384 * @param RIC Actions Required To Be Removed List to be filled
6385 * Number of actions to be removed
6386 * RIC Subscription DB
6387 * @return ROK - success
6390 ******************************************************************/
6391 uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \
6392 RicSubscription *ricSubscription)
6395 CmLList *actionNode = NULLP;
6396 ActionInfo *actionDb = NULLP;
6397 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL;
6399 actionToBeRmvList->list.count = numActionsRmv;
6400 actionToBeRmvList->list.size = numActionsRmv * sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t *);
6401 DU_ALLOC(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6402 if(!actionToBeRmvList->list.array)
6404 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6409 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6412 actionDb = (ActionInfo*)(actionNode->node);
6413 if(actionDb->action == CONFIG_DEL)
6415 DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6416 if(!actionToBeRmvList->list.array[arrIdx])
6418 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6421 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[arrIdx];
6423 actionToBeRmv->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeRemoved_Item;
6424 actionToBeRmv->criticality = CriticalityE2_reject;
6425 actionToBeRmv->value.present = \
6426 RICaction_RequiredToBeRemoved_ItemIEs__value_PR_RICaction_RequiredToBeRemoved_Item;
6427 actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = actionDb->actionId;
6428 fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, actionDb->failureCause);
6436 /*******************************************************************
6438 * @brief Fill RIC Subscription Modification Required IEs
6442 * Function : FillRicSubsModRequired
6444 * Functionality: Fill RIC Subscription Modification Required IEs
6446 * @param RIC Subscription Modification Required IEs to be filled
6447 * RIC Subscription DB
6448 * @return ROK - success
6451 ******************************************************************/
6452 uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription)
6454 ActionInfo * actionDb=NULLP;
6455 CmLList *actionNode = NULLP;
6456 uint8_t ieIdx = 0, elementCnt=0;
6457 uint8_t numActionsMod = 0, numActionsRmv = 0;
6458 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6459 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6461 /* Unused in case of E2SM-KPM */
6463 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6466 /* Count number of Actions to be modified or deleted */
6467 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6470 actionDb = (ActionInfo*)(actionNode->node);
6471 if(actionDb->action == CONFIG_MOD)
6473 else if(actionDb->action == CONFIG_DEL)
6475 actionNode = actionNode->next;
6478 /* Count number of IEs to be added to messages */
6485 ricSubsModReqd->protocolIEs.list.count = elementCnt;
6486 ricSubsModReqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequired_IEs_t *);
6487 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6488 if(!ricSubsModReqd->protocolIEs.list.array)
6490 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6494 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
6496 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRequired_IEs_t));
6497 if(!ricSubsModReqd->protocolIEs.list.array[ieIdx])
6499 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6504 /* RIC Request ID */
6506 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6507 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICrequestID;
6508 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6509 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RICrequestID;
6510 ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID = ricSubscription->requestId.requestorId;
6511 ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID = ricSubscription->requestId.instanceId;
6513 /* RAN Function ID */
6515 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6516 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RANfunctionID;
6517 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6518 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RANfunctionID;
6519 ricSubsModReqdIe->value.choice.RANfunctionID = ricSubscription->ranFuncId;
6521 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6522 * However, E2SM-KPM supports only RIC Report service.
6523 * Hence there is no subsequent action in RIC subscription that may require modification.
6524 * So commenting the action-modification IEs for the time being
6527 /* RIC Actions Required to be Modified */
6531 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6532 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List;
6533 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6534 ricSubsModReqdIe->value.present = \
6535 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeModified_List;
6536 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6538 if(FillActionReqdToBeModList(actionToBeModList, numActionsMod, ricSubscription) != ROK)
6540 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__);
6546 /* RIC Actions Required to be removed */
6550 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6551 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List;
6552 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6553 ricSubsModReqdIe->value.present = \
6554 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeRemoved_List;
6555 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6557 if(FillActionReqdToBeRmvList(actionToBeRmvList, numActionsRmv, ricSubscription) != ROK)
6559 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__);
6567 /*******************************************************************
6569 * @brief Builds and Send RIC Subscription Modification Required
6574 * Function : BuildAndSendRicSubsModRequired
6576 * Functionality: Builds and Send RIC Subscription Modification
6579 * @param RIC Subscription DB
6580 * @return ROK - success
6583 ******************************************************************/
6584 uint8_t BuildAndSendRicSubsModRequired(RicSubscription *ricSubscription)
6586 uint8_t ret = RFAILED;
6587 E2AP_PDU_t *e2apMsg = NULLP;
6588 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6589 asn_enc_rval_t encRetVal; /* Encoder return value */
6591 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Required \n");
6594 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6595 if(e2apMsg == NULLP)
6597 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6601 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6602 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6603 if(e2apMsg->choice.initiatingMessage == NULLP)
6605 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6608 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6609 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
6610 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired;
6612 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6614 if(FillRicSubsModRequired(ricSubsModReqd, ricSubscription) != ROK)
6616 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__);
6621 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6623 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6625 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6626 if(encRetVal.encoded == ENCODE_FAIL)
6628 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modifiction Required structure (at %s)\n",\
6629 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6634 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Required \n");
6635 #ifdef DEBUG_ASN_PRINT
6636 for(int i=0; i< encBufSize; i++)
6638 printf("%x",encBuf[i]);
6642 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
6644 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Modification Required failed");
6651 /* Free RIC Subscription modification required */
6652 FreeRicSubsModRequired(e2apMsg);
6656 /*******************************************************************
6658 * @brief Free APER decoding of RIC Subscription Modification Confirm
6662 * Function : freeAperDecodingOfRicSubsModConfirm
6664 * Functionality: Free APER decoding of RIC Subscription
6665 * Modification Confirm
6667 * @param E2AP Message PDU
6670 ******************************************************************/
6671 void freeAperDecodingOfRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
6673 uint8_t ieIdx = 0, arrIdx=0;
6674 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6675 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6676 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6677 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6678 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6679 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6681 if(e2apMsg && e2apMsg->choice.successfulOutcome)
6683 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6684 if(ricSubsModCfm->protocolIEs.list.array)
6686 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6688 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
6690 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6691 switch(ricSubsModCfmIe->id)
6693 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6695 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6696 if(modCfmList->list.array)
6698 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6700 if(modCfmList->list.array[arrIdx])
6701 free(modCfmList->list.array[arrIdx]);
6703 free(modCfmList->list.array);
6708 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6710 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6711 if(modRefusedList->list.array)
6713 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6715 if(modRefusedList->list.array[arrIdx])
6716 free(modRefusedList->list.array[arrIdx]);
6718 free(modRefusedList->list.array);
6723 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6725 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6726 if(rmvCfmList->list.array)
6728 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6730 if(rmvCfmList->list.array[arrIdx])
6731 free(rmvCfmList->list.array[arrIdx]);
6733 free(rmvCfmList->list.array);
6738 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6740 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6741 if(rmvFailList->list.array)
6743 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6745 if(rmvFailList->list.array[arrIdx])
6746 free(rmvFailList->list.array[arrIdx]);
6748 free(rmvFailList->list.array);
6757 free(ricSubsModCfmIe);
6760 free(ricSubsModCfm->protocolIEs.list.array);
6765 /*******************************************************************
6767 * @brief Process RIC Subscription Modification Confirm Message
6771 * Function : procRicSubscriptionModificationConfirm
6773 * Functionality: Process RIC Subscription Modification Confirm
6774 * Message received from RIC.
6776 * @param E2AP Message PDU
6779 ******************************************************************/
6780 void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg)
6782 uint8_t actionId = 0, ieIdx = 0, arrIdx = 0;
6783 uint16_t ranFuncId = 0;
6784 bool procFailure = false;
6785 RicRequestId ricReqId;
6786 RanFunction *ranFuncDb = NULLP;
6787 CmLList *ricSubsNode = NULLP;
6788 CmLList *actionNode= NULLP;
6789 RicSubscription *ricSubsDb = NULLP;
6790 ActionInfo *actionDb = NULLP;
6792 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6793 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6795 /* Not used in case of E2SM-KPM */
6797 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6798 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
6800 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6801 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
6804 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6805 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
6807 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6808 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
6810 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Confirm", __func__);
6815 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
6819 if(!e2apMsg->choice.successfulOutcome)
6821 DU_LOG("\nERROR --> E2AP : %s: Successful Outcome in E2AP message is NULL", __func__);
6825 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6826 if(!ricSubsModCfm->protocolIEs.list.array)
6828 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
6832 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6834 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
6836 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
6840 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6841 switch(ricSubsModCfmIe->id)
6843 case ProtocolIE_IDE2_id_RICrequestID:
6845 memset(&ricReqId, 0, sizeof(RicRequestId));
6846 ricReqId.requestorId = ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID;
6847 ricReqId.instanceId = ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID;
6851 case ProtocolIE_IDE2_id_RANfunctionID:
6853 ranFuncId = ricSubsModCfmIe->value.choice.RANfunctionID;
6854 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
6857 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
6862 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
6865 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
6866 __func__, ricReqId.requestorId, ricReqId.instanceId);
6874 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6875 * However, E2SM-KPM supports only RIC Report service.
6876 * Hence there is no subsequent action in RIC subscription that may require modification.
6877 * So commenting the action-modification IEs for the time being
6880 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6882 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6883 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6885 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
6886 actionId = modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID;
6888 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6891 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6895 actionDb->action = CONFIG_UNKNOWN;
6896 /* Further handling can be added here in future once the
6897 * use case of this procedure is identified */
6904 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6906 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6907 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6909 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
6910 actionId = modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID;
6911 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6914 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6918 /* Spec doesnt mention if in case of failure, DU should retry for modify action
6919 * Hence, chaging the action from CONFIG_MOD to CONFIG_UNKNOWN
6921 actionDb->action = CONFIG_UNKNOWN;
6929 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6931 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6932 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6934 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
6935 actionId = rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID;
6936 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6939 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6943 cmLListDelFrm(&ricSubsDb->actionSequence, actionNode);
6944 deleteActionSequence(actionNode);
6946 /* Further handling can include :
6947 * Deletion of this action from all DU layers
6955 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6957 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6958 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6960 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
6961 actionId = rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID;
6962 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6965 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6969 actionDb->action = CONFIG_UNKNOWN;
6978 } /* End of switch for Protocol IE Id */
6982 } /* End of for loop for Protocol IE list */
6987 freeAperDecodingOfRicSubsModConfirm(e2apMsg);
6991 /******************************************************************
6992 * @brief Deallocate the memory allocated for E2 Reset Response
6996 * Function : FreeE2ResetResponse
6999 * - freeing the memory allocated for E2ResetResponse
7001 * @params[in] E2AP_PDU_t *e2apMsg
7002 * @return ROK - success
7005 * ****************************************************************/
7006 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
7009 ResetResponseE2_t *resetResponse;
7011 if(e2apMsg != NULLP)
7013 if(e2apMsg->choice.successfulOutcome != NULLP)
7015 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
7016 if(resetResponse->protocolIEs.list.array)
7018 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
7020 if(resetResponse->protocolIEs.list.array[ieIdx])
7022 DU_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
7025 DU_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
7028 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7030 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
7034 /*******************************************************************
7036 * @brief Buld and send the E2 Reset Response msg
7040 * Function : BuildAndSendE2ResetResponse
7043 * - Buld and send the E2 Reset Response Message
7045 * @params[in] Trans Id
7046 * @return ROK - success
7049 * ****************************************************************/
7050 uint8_t BuildAndSendResetResponse(uint16_t transId)
7052 uint8_t ieIdx = 0, elementCnt = 0;
7053 uint8_t ret = RFAILED;
7054 E2AP_PDU_t *e2apMsg = NULLP;
7055 ResetResponseE2_t *resetResponse;
7056 asn_enc_rval_t encRetVal; /* Encoder return value */
7058 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
7061 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7062 if(e2apMsg == NULLP)
7064 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
7067 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7069 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7070 if(e2apMsg->choice.successfulOutcome == NULLP)
7072 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
7076 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
7077 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7078 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
7079 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
7082 resetResponse->protocolIEs.list.count = elementCnt;
7083 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
7084 DU_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
7085 if(!resetResponse->protocolIEs.list.array)
7087 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
7091 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
7093 DU_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
7094 if(!resetResponse->protocolIEs.list.array[ieIdx])
7096 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
7100 if(ieIdx < elementCnt)
7104 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
7105 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
7106 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
7107 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
7109 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7111 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7113 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7114 if(encRetVal.encoded == ENCODE_FAIL)
7116 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
7117 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7122 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
7123 for(int i=0; i< encBufSize; i++)
7125 DU_LOG("%x",encBuf[i]);
7130 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7132 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
7140 FreeE2ResetResponse(e2apMsg);
7144 /******************************************************************
7146 * @brief Deallocation of memory allocated by aper decoder for reset req
7150 * Function : freeAperDecodingOfE2ResetReq
7152 * Functionality: Deallocation of memory allocated by aper decoder for
7155 * @params[in] Pointer to resetReq
7158 * ****************************************************************/
7159 void freeAperDecodingOfE2ResetReq(ResetRequestE2_t *resetReq)
7165 if(resetReq->protocolIEs.list.array)
7167 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7169 if(resetReq->protocolIEs.list.array[arrIdx])
7171 free(resetReq->protocolIEs.list.array[arrIdx]);
7174 free(resetReq->protocolIEs.list.array);
7179 /*******************************************************************
7181 * @brief Process reset req received from RIC
7185 * Function : procE2ResetRequest
7187 * Functionality: Process reset req received from RIC
7189 * @param E2AP_PDU_t *e2apMsg
7192 ******************************************************************/
7194 void procE2ResetRequest(E2AP_PDU_t *e2apMsg)
7197 uint16_t transId =0;
7198 uint16_t ranFuncIdx=0;
7199 ResetRequestE2_t *resetReq;
7201 DU_LOG("\nINFO --> E2AP : E2 Reset request received");
7202 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
7204 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7206 switch(resetReq->protocolIEs.list.array[arrIdx]->id)
7208 case ProtocolIE_IDE2_id_TransactionID:
7210 transId = resetReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
7214 case ProtocolIE_IDE2_id_CauseE2:
7216 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
7218 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
7220 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
7221 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
7228 if(BuildAndSendResetResponse(transId) != ROK)
7230 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
7232 freeAperDecodingOfE2ResetReq(resetReq);
7235 /*******************************************************************
7237 * @brief Free APER decoding of RIC Subscription Modification Refuse
7241 * Function : freeAperDecodingOfRicSubsModRefuse
7243 * Functionality: Free APER decoding of RIC Subscription
7244 * Modification Refuse
7246 * @param E2AP Message PDU
7249 ******************************************************************/
7250 void freeAperDecodingOfRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
7253 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7255 if(e2apMsg && e2apMsg->choice.unsuccessfulOutcome)
7257 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7258 if(ricSubsModRefuse->protocolIEs.list.array)
7260 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7262 if(ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7263 free(ricSubsModRefuse->protocolIEs.list.array[ieIdx]);
7265 free(ricSubsModRefuse->protocolIEs.list.array);
7270 /*******************************************************************
7272 * @brief Process RIC Subscription Modification Refuse Message
7276 * Function : procRicSubscriptionModificationRefuse
7278 * Functionality: Process RIC Subscription Modification Refuse
7279 * Message received from RIC.
7281 * @param E2AP Message PDU
7284 ******************************************************************/
7285 void procRicSubscriptionModificationRefuse(E2AP_PDU_t *e2apMsg)
7288 uint16_t ranFuncId = 0;
7289 RicRequestId ricReqId;
7290 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7291 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
7292 CauseE2_t *cause = NULLP;
7294 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Refuse", __func__);
7299 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
7303 if(!e2apMsg->choice.unsuccessfulOutcome)
7305 DU_LOG("\nERROR --> E2AP : %s: Unsuccessful Outcome in E2AP message is NULL", __func__);
7309 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7310 if(!ricSubsModRefuse->protocolIEs.list.array)
7312 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
7316 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7318 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7320 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
7324 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
7325 switch(ricSubsModRefuseIe->id)
7327 case ProtocolIE_IDE2_id_RICrequestID:
7329 memset(&ricReqId, 0, sizeof(RicRequestId));
7330 ricReqId.requestorId = ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID;
7331 ricReqId.instanceId = ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID;
7335 case ProtocolIE_IDE2_id_RANfunctionID:
7337 ranFuncId = ricSubsModRefuseIe->value.choice.RANfunctionID;
7341 case ProtocolIE_IDE2_id_CauseE2:
7343 DU_LOG("\nDEBUG --> E2AP : %s: RIC subscriptiom modification refused for RIC_Requestor_ID [%d] \
7344 RIC_Instance_ID [%d] RAN_Function_ID [%d] ", __func__, ricReqId.requestorId, \
7345 ricReqId.instanceId, ranFuncId);
7347 cause = &ricSubsModRefuseIe->value.choice.CauseE2;
7348 printE2ErrorCause(cause);
7353 } /* End of switch for Protocol IE Id */
7354 } /* End of for loop for Protocol IE list */
7359 freeAperDecodingOfRicSubsModRefuse(e2apMsg);
7363 /*******************************************************************
7365 * @brief Free RIC Subscription Delete Required Message
7369 * Function : FreeRicSubscriptionDeleteRequired
7371 * Functionality: Free RIC Subscription Delete Required
7373 * @param E2AP Message PDU
7376 ******************************************************************/
7377 void FreeRicSubscriptionDeleteRequired(E2AP_PDU_t *e2apMsg, CmLListCp *ricSubsToBeDelList)
7379 uint8_t ieIdx = 0, arrIdx = 0;
7380 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7381 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7382 RICsubscription_List_withCause_t *ricSubsList = NULLP;
7383 CmLList *subsNode = NULLP;
7387 if(e2apMsg->choice.initiatingMessage)
7389 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7390 if(ricSubsDelRqd->protocolIEs.list.array)
7392 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
7394 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx])
7396 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7397 switch(ricSubsDelRqdIe->id)
7399 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
7401 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
7402 if(ricSubsList->list.array)
7404 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
7406 DU_FREE(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7408 DU_FREE(ricSubsList->list.array, ricSubsList->list.size);
7413 DU_FREE(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7416 DU_FREE(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7418 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7420 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7423 if(ricSubsToBeDelList)
7425 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7428 cmLListDelFrm(ricSubsToBeDelList, subsNode);
7429 DU_FREE(subsNode, sizeof(CmLList));
7430 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7435 /*******************************************************************
7437 * @brief Fill list of RIC subscriptions required to be deleted
7438 * with the cause of deletion
7442 * Function : fillRicSubsListWithCause
7444 * Functionality: Fill list of RIC subscriptions required to be
7445 * deleted with the cause of deletion
7447 * @param E2AP Message PDU
7450 ******************************************************************/
7451 uint8_t fillRicSubsListWithCause(RICsubscription_List_withCause_t *ricSubsList, CmLListCp ricSubsToBeDelList)
7454 CmLList *subsNode = NULLP;
7455 RicSubscription *subsInfo = NULLP;
7456 RICsubscription_withCause_ItemIEs_t *subsItemIe = NULLP;
7457 RICsubscription_withCause_Item_t *subsItem = NULLP;
7459 ricSubsList->list.count = ricSubsToBeDelList.count;
7460 ricSubsList->list.size = ricSubsList->list.count * sizeof(RICsubscription_withCause_ItemIEs_t *);
7461 DU_ALLOC(ricSubsList->list.array, ricSubsList->list.size);
7462 if(!ricSubsList->list.array)
7464 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7468 CM_LLIST_FIRST_NODE(&ricSubsToBeDelList, subsNode);
7469 while(subsNode && (ieIdx < ricSubsList->list.count))
7471 subsInfo = (RicSubscription *)subsNode->node;
7472 DU_ALLOC(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7473 if(!ricSubsList->list.array[ieIdx])
7475 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7479 subsItemIe = (RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[ieIdx];
7480 subsItemIe->id = ProtocolIE_IDE2_id_RICsubscription_withCause_Item;
7481 subsItemIe->criticality = CriticalityE2_ignore;
7482 subsItemIe->value.present = RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item;
7484 subsItem = & subsItemIe->value.choice.RICsubscription_withCause_Item;
7485 subsItem->ricRequestID.ricRequestorID = subsInfo->requestId.requestorId;
7486 subsItem->ricRequestID.ricInstanceID = subsInfo->requestId.instanceId;
7487 subsItem->ranFunctionID = subsInfo->ranFuncId;
7488 fillE2Cause(&subsItem->cause, subsInfo->failureCause);
7491 subsNode = subsNode->next;
7497 /*******************************************************************
7499 * @brief Builds and Send RIC Subscription delete required
7503 * Function : BuildAndSendRicSubscriptionDeleteRequired
7505 * Functionality: Build and send RIC subscription delete required.
7506 * There can be 2 approaches to trigger following. One of these
7507 * approaches may/may not be implemented in future:
7508 * 1. It can be triggerred immediately when a RIC subscription's
7509 * End Time has expired. In this case, only this subscription's
7510 * info will be sent in this message.
7511 * Since we have not yet added support to execute RIC
7512 * Subscription based on Start Time and End Timer, this message is
7513 * not triggered anywhere from DU APP yet.
7514 * 2. Another approach is to have a periodic timer to check subscription
7515 * status running in background.
7516 * When RIC Subscription End Time expires, this subscription is
7517 * marked to be deleted. Later when this background timer expires,
7518 * a RIC Subscription delete required is sent with all the
7519 * subscription's info which is marked to be deleted.
7520 * The following function is implemented keeping in mind the second
7524 * @return ROK - success
7527 ******************************************************************/
7528 uint8_t BuildAndSendRicSubscriptionDeleteRequired()
7530 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7531 E2AP_PDU_t *e2apMsg = NULLP;
7532 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7533 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7534 asn_enc_rval_t encRetVal; /* Encoder return value */
7535 CmLListCp ricSubsToBeDelList;
7539 /* Check if there are any RIC subscriptions to be deleted */
7540 cmLListInit(&ricSubsToBeDelList);
7541 fetchRicSubsToBeDeleted(&ricSubsToBeDelList);
7542 if(ricSubsToBeDelList.count == 0)
7544 DU_LOG("\nDEBUG --> E2AP : %s: No RIC subscriptions are required to be deleted", __func__);
7548 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Required Message\n");
7550 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7551 if(e2apMsg == NULLP)
7553 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7557 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
7558 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7559 if(e2apMsg->choice.initiatingMessage == NULLP)
7561 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7564 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDeleteRequired;
7565 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
7566 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired;
7568 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7571 ricSubsDelRqd->protocolIEs.list.count = elementCnt;
7572 ricSubsDelRqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequired_IEs_t *);
7574 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7575 if(ricSubsDelRqd->protocolIEs.list.array == NULLP)
7577 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7581 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7583 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7584 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx] == NULLP)
7586 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7587 __func__, ieIdx, __LINE__);
7591 if(ieIdx < elementCnt)
7595 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7596 ricSubsDelRqdIe->id = ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved;
7597 ricSubsDelRqdIe->criticality = CriticalityE2_ignore;
7598 ricSubsDelRqdIe->value.present = RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause;
7599 if(fillRicSubsListWithCause(&ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause, ricSubsToBeDelList)\
7602 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription list with cause", __func__);
7606 /* Prints the Msg formed */
7607 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7608 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7610 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7611 if(encRetVal.encoded == ENCODE_FAIL)
7613 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Required Message (at %s)\n",\
7614 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7619 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Required Message \n");
7620 #ifdef DEBUG_ASN_PRINT
7621 for(int i=0; i< encBufSize; i++)
7623 printf("%x",encBuf[i]);
7628 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7630 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Required Message");
7637 FreeRicSubscriptionDeleteRequired(e2apMsg, &ricSubsToBeDelList);
7641 /*******************************************************************
7643 * @brief Free RIC Subscription Delete Failure Message
7647 * Function : FreeRicSubscriptionDeleteFailure
7649 * Functionality: Free RIC Subscription Delete Failure
7651 * @param E2AP Message PDU
7654 ******************************************************************/
7655 void FreeRicSubscriptionDeleteFailure(E2AP_PDU_t *e2apMsg)
7658 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7662 if(e2apMsg->choice.unsuccessfulOutcome)
7664 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7665 if(ricSubsDelFailure->protocolIEs.list.array)
7667 for(ieIdx = 0; ieIdx < ricSubsDelFailure->protocolIEs.list.count; ieIdx++)
7669 DU_FREE(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7671 DU_FREE(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7673 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7675 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7679 /*******************************************************************
7681 * @brief Builds and Send RIC Subscription Delete Failure
7685 * Function : BuildAndSendRicSubscriptionDeleteFailure
7687 * Functionality: Build and send RIC Subscription Delete Failure.
7693 * @return ROK - success
7696 ******************************************************************/
7697 uint8_t BuildAndSendRicSubscriptionDeleteFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
7699 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7700 E2AP_PDU_t *e2apMsg = NULLP;
7701 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7702 RICsubscriptionDeleteFailure_IEs_t *ricSubsDelFailureIe = NULLP;
7703 asn_enc_rval_t encRetVal; /* Encoder return value */
7707 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Failure Message\n");
7709 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7710 if(e2apMsg == NULLP)
7712 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7716 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
7717 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7718 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
7720 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7723 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7724 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
7725 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteFailure;
7728 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7731 ricSubsDelFailure->protocolIEs.list.count = elementCnt;
7732 ricSubsDelFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteFailure_IEs_t *);
7734 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7735 if(ricSubsDelFailure->protocolIEs.list.array == NULLP)
7737 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7741 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7743 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7744 if(ricSubsDelFailure->protocolIEs.list.array[ieIdx] == NULLP)
7746 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7747 __func__, ieIdx, __LINE__);
7751 if(ieIdx < elementCnt)
7755 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7756 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
7757 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7758 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
7759 ricSubsDelFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7760 ricSubsDelFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7763 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7764 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7765 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7766 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
7767 ricSubsDelFailureIe->value.choice.RANfunctionID = ranFuncId;
7770 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7771 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
7772 ricSubsDelFailureIe->criticality = CriticalityE2_ignore;
7773 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_CauseE2;
7774 fillE2Cause(&ricSubsDelFailureIe->value.choice.CauseE2, failureCause);
7776 /* Prints the Msg formed */
7777 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7778 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7780 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7781 if(encRetVal.encoded == ENCODE_FAIL)
7783 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Failure Message (at %s)\n",\
7784 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7789 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Failure Message \n");
7790 #ifdef DEBUG_ASN_PRINT
7791 for(int i=0; i< encBufSize; i++)
7793 printf("%x",encBuf[i]);
7798 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7800 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Failure Message");
7808 FreeRicSubscriptionDeleteFailure(e2apMsg);
7813 /*******************************************************************
7815 * @brief Free RIC Subscription Delete Response Message
7819 * Function : FreeRicSubscriptionDeleteResponse
7821 * Functionality: Free RIC Subscription Delete Response
7823 * @param E2AP Message PDU
7826 ******************************************************************/
7827 void FreeRicSubscriptionDeleteResponse(E2AP_PDU_t *e2apMsg)
7830 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7834 if(e2apMsg->choice.successfulOutcome)
7836 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7837 if(ricSubsDelRsp->protocolIEs.list.array)
7839 for(ieIdx = 0; ieIdx < ricSubsDelRsp->protocolIEs.list.count; ieIdx++)
7841 DU_FREE(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7843 DU_FREE(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7845 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7847 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7851 /*******************************************************************
7853 * @brief Builds and Send RIC Subscription delete Response
7857 * Function : BuildAndSendRicSubscriptionDeleteResponse
7859 * Functionality: Build and send RIC subscription delete Response.
7864 * @return ROK - success
7867 ******************************************************************/
7868 uint8_t BuildAndSendRicSubscriptionDeleteResponse(uint16_t ranFuncId, RicRequestId requestId)
7870 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7871 E2AP_PDU_t *e2apMsg = NULLP;
7872 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7873 RICsubscriptionDeleteResponse_IEs_t *ricSubsDelRspIe = NULLP;
7874 asn_enc_rval_t encRetVal; /* Encoder return value */
7878 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Response Message\n");
7880 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7881 if(e2apMsg == NULLP)
7883 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7887 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7888 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7889 if(e2apMsg->choice.successfulOutcome == NULLP)
7891 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7894 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7895 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7896 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse;
7899 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7902 ricSubsDelRsp->protocolIEs.list.count = elementCnt;
7903 ricSubsDelRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteResponse_IEs_t *);
7905 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7906 if(ricSubsDelRsp->protocolIEs.list.array == NULLP)
7908 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7912 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7914 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7915 if(ricSubsDelRsp->protocolIEs.list.array[ieIdx] == NULLP)
7917 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7918 __func__, ieIdx, __LINE__);
7922 if(ieIdx < elementCnt)
7926 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7927 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
7928 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7929 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
7930 ricSubsDelRspIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7931 ricSubsDelRspIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7934 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7935 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7936 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7937 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
7938 ricSubsDelRspIe->value.choice.RANfunctionID = ranFuncId;
7940 /* Prints the Msg formed */
7941 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7942 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7944 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7945 if(encRetVal.encoded == ENCODE_FAIL)
7947 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Response Message (at %s)\n",\
7948 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7953 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Response Message \n");
7954 #ifdef DEBUG_ASN_PRINT
7955 for(int i=0; i< encBufSize; i++)
7957 printf("%x",encBuf[i]);
7962 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7964 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Response Message");
7972 FreeRicSubscriptionDeleteResponse(e2apMsg);
7976 /*******************************************************************
7978 * @brief Free RIC Subscription Delete Request Message
7982 * Function : freeAperDecodingOfRicSubsDeleteReq
7984 * Functionality: Free RIC Subscription Delete Request
7986 * @param E2AP Message PDU
7989 ******************************************************************/
7990 void freeAperDecodingOfRicSubsDeleteReq(E2AP_PDU_t *e2apMsg)
7993 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
7997 if(e2apMsg->choice.initiatingMessage)
7999 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
8000 if(ricSubsDelReq->protocolIEs.list.array)
8002 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
8004 if(ricSubsDelReq->protocolIEs.list.array[ieIdx])
8006 free(ricSubsDelReq->protocolIEs.list.array[ieIdx]);
8009 free(ricSubsDelReq->protocolIEs.list.array);
8015 /*******************************************************************
8017 * @brief Process RIC Subscription delete request
8021 * Function : procRicSubscriptionDeleteRequest
8023 * Functionality: Process RIC subscription delete request.
8024 * Fetch RAN Function and RIC subscription to be deleted.
8025 * Send statistics delete request to MAC for all action sequence
8026 * within this RIC subscription.
8028 * @params[in] E2AP PDU
8031 ******************************************************************/
8032 void procRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
8035 uint16_t ranFuncId = 0;
8036 bool procFailure = false;
8037 RicRequestId ricReqId;
8038 RanFunction *ranFuncDb = NULLP;
8039 CmLList *ricSubsNode = NULLP;
8040 RicSubscription *ricSubsDb = NULLP;
8041 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
8042 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
8044 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Delete Request", __func__);
8049 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
8053 if(!e2apMsg->choice.initiatingMessage)
8055 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
8059 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
8060 if(!ricSubsDelReq->protocolIEs.list.array)
8062 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
8066 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
8068 if(!ricSubsDelReq->protocolIEs.list.array[ieIdx])
8070 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
8074 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
8075 switch(ricSubsDelReqIe->id)
8077 case ProtocolIE_IDE2_id_RICrequestID:
8079 memset(&ricReqId, 0, sizeof(RicRequestId));
8080 ricReqId.requestorId = ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID;
8081 ricReqId.instanceId = ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID;
8085 case ProtocolIE_IDE2_id_RANfunctionID:
8087 ranFuncId = ricSubsDelReqIe->value.choice.RANfunctionID;
8088 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
8091 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
8096 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
8099 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
8100 __func__, ricReqId.requestorId, ricReqId.instanceId);
8105 if(BuildAndSendStatsDeleteReq(ricSubsDb, true) != ROK)
8107 DU_LOG("\nERROR --> E2AP : Failed to build and send ric subscription delete req to du layers");
8114 } /* End of switch for Protocol IE Id */
8118 } /* End of for loop for Protocol IE list */
8123 freeAperDecodingOfRicSubsDeleteReq(e2apMsg);
8127 /*******************************************************************
8129 * @brief Deallocate the memory allocated for E2 node configuration
8130 * update ack msg by aper decoder
8134 * Function : freeAperDecodingOfE2NodeConfigUpdateAck
8137 * - Deallocate the memory allocated for E2 node configuration
8138 * update ack msg by aper decoder
8140 * @params[in] E2AP_PDU_t *e2apMsg
8141 * @return ROK - success
8144 * ****************************************************************/
8146 void freeAperDecodingOfE2NodeConfigUpdateAck(E2nodeConfigurationUpdateAcknowledge_t *updateAckMsg)
8148 uint8_t arrIdx =0, e2NodeConfigIdx=0;
8149 E2nodeComponentConfigUpdateAck_ItemIEs_t *updateAckItemIe=NULL;
8150 E2nodeComponentConfigUpdateAck_List_t *updateAckList=NULL;
8151 E2nodeComponentConfigRemovalAck_ItemIEs_t *removalAckItemIe=NULL;
8152 E2nodeComponentConfigRemovalAck_List_t *removalAckList=NULL;
8153 E2nodeComponentConfigAdditionAck_ItemIEs_t *additionAckItemIte=NULL;
8154 E2nodeComponentConfigAdditionAck_List_t *additionAckList=NULL;
8156 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULLP;
8157 if(updateAckMsg->protocolIEs.list.array != NULLP)
8159 for(arrIdx = 0; arrIdx < updateAckMsg->protocolIEs.list.count; arrIdx++)
8161 if(updateAckMsg->protocolIEs.list.array[arrIdx])
8163 switch(updateAckMsg->protocolIEs.list.array[arrIdx]->id)
8165 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8167 additionAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8168 if(additionAckList->list.array)
8170 for(e2NodeConfigIdx=0; e2NodeConfigIdx<additionAckList->list.count; e2NodeConfigIdx++)
8172 additionAckItemIte = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) additionAckList->list.array[e2NodeConfigIdx];
8173 if(additionAckItemIte)
8175 switch(additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present)
8177 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8179 f1InterfaceInfo = additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8180 free(f1InterfaceInfo->gNB_DU_ID.buf);
8181 free(f1InterfaceInfo);
8187 free(additionAckItemIte);
8189 free(additionAckList->list.array);
8194 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8196 updateAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8197 if(updateAckList->list.array)
8199 for(e2NodeConfigIdx=0; e2NodeConfigIdx<updateAckList->list.count; e2NodeConfigIdx++)
8201 updateAckItemIe = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) updateAckList->list.array[e2NodeConfigIdx];
8204 switch(updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.present)
8206 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8208 f1InterfaceInfo = updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8209 free(f1InterfaceInfo->gNB_DU_ID.buf);
8210 free(f1InterfaceInfo);
8216 free(updateAckItemIe);
8219 free(updateAckList->list.array);
8223 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8225 removalAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8226 if(removalAckList->list.array)
8228 for(e2NodeConfigIdx=0; e2NodeConfigIdx<removalAckList->list.count; e2NodeConfigIdx++)
8230 removalAckItemIe = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) removalAckList->list.array[e2NodeConfigIdx];
8231 if(removalAckItemIe)
8233 switch(removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.present)
8235 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8237 f1InterfaceInfo = removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8238 free(f1InterfaceInfo->gNB_DU_ID.buf);
8239 free(f1InterfaceInfo);
8245 free(removalAckItemIe);
8248 free(removalAckList->list.array);
8253 free(updateAckMsg->protocolIEs.list.array[arrIdx]);
8256 free(updateAckMsg->protocolIEs.list.array);
8260 /******************************************************************
8262 * @brief Processes the E2 node config update ack msg
8266 * Function :procE2NodeConfigUpdateAck
8268 * Functionality: Processes the E2 node config update ack msg
8270 * @params[in] E2AP_PDU_t ASN decoded E2AP message
8271 * @return ROK - success
8274 * ****************************************************************/
8276 void procE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
8279 uint16_t e2CfgIdx =0;
8280 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck =NULLP;
8281 E2nodeComponentConfigUpdateAck_List_t *e2NodeConfigUpdateAckList=NULLP;
8282 E2nodeComponentConfigUpdateAck_ItemIEs_t *e2NodeUpdateAckItem=NULLP;
8283 E2nodeComponentConfigRemovalAck_List_t *e2NodeConfigRemovalAckList=NULLP;
8284 E2nodeComponentConfigRemovalAck_ItemIEs_t *e2NodeRemovalAckItem=NULLP;
8285 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULLP;
8286 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAdditionAckItem=NULLP;
8288 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
8290 if(e2NodeConfigUpdateAck->protocolIEs.list.array)
8292 for(arrIdx =0; arrIdx<e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
8294 switch(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id)
8296 case ProtocolIE_IDE2_id_TransactionID:
8300 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8302 e2NodeConfigAdditionAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8303 if(e2NodeConfigAdditionAckList->list.array)
8305 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigAdditionAckList->list.count; e2CfgIdx++)
8307 e2NodeAdditionAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2CfgIdx];
8308 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAdditionAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
8309 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
8314 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8316 e2NodeConfigUpdateAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8317 if(e2NodeConfigUpdateAckList->list.array)
8319 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigUpdateAckList->list.count; e2CfgIdx++)
8321 e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[e2CfgIdx];
8322 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeUpdateAckItem->value.choice.E2nodeComponentConfigUpdateAck_Item,\
8323 ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck);
8328 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8330 e2NodeConfigRemovalAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8331 if(e2NodeConfigRemovalAckList->list.array)
8333 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigRemovalAckList->list.count; e2CfgIdx++)
8335 e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[e2CfgIdx];
8336 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeRemovalAckItem->value.choice.E2nodeComponentConfigRemovalAck_Item,\
8337 ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck);
8346 freeAperDecodingOfE2NodeConfigUpdateAck(e2NodeConfigUpdateAck);
8349 /*******************************************************************
8351 * @brief Deallocate the memory allocated for RemovalRequest msg
8355 * Function : FreeRemovalRequest
8358 * - freeing the memory allocated for RemovalRequest
8360 * @params[in] E2AP_PDU_t *e2apMsg
8361 * @return ROK - success
8364 * ****************************************************************/
8365 void FreeRemovalRequest(E2AP_PDU_t *e2apMsg)
8368 E2RemovalRequest_t *removalReq = NULLP;
8370 if(e2apMsg != NULLP)
8372 if(e2apMsg->choice.initiatingMessage != NULLP)
8374 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8375 if(removalReq->protocolIEs.list.array)
8377 for(ieIdx = 0; ieIdx < removalReq->protocolIEs.list.count; ieIdx++)
8379 DU_FREE(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8381 DU_FREE(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8383 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8385 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8389 /*******************************************************************
8391 * @brief Build and send the removal request msg
8395 * Function : BuildAndSendRemovalRequest
8398 * - Buld and send the removal request msg to E2 node
8400 * @return ROK - success
8403 * ****************************************************************/
8405 uint8_t BuildAndSendRemovalRequest()
8407 uint16_t transId = 0;
8408 uint8_t ret = RFAILED;
8409 uint8_t ieIdx = 0, elementCnt = 0;
8410 E2AP_PDU_t *e2apMsg = NULLP;
8411 E2RemovalRequest_t *removalReq = NULLP;
8412 asn_enc_rval_t encRetVal; /* Encoder return value */
8414 DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
8418 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8419 if(e2apMsg == NULLP)
8421 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8425 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
8426 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8427 if(e2apMsg->choice.initiatingMessage == NULLP)
8429 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8433 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2removal;
8434 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
8435 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2RemovalRequest;
8436 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8439 removalReq->protocolIEs.list.count = elementCnt;
8440 removalReq->protocolIEs.list.size = elementCnt * sizeof(E2RemovalRequestIEs_t *);
8442 DU_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8443 if(!removalReq->protocolIEs.list.array)
8445 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8449 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
8451 DU_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8452 if(!removalReq->protocolIEs.list.array[ieIdx])
8454 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8459 /* In case of failure */
8460 if(ieIdx < elementCnt)
8464 removalReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8465 removalReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8466 removalReq->protocolIEs.list.array[ieIdx]->value.present = E2RemovalRequestIEs__value_PR_TransactionID;
8467 transId = assignTransactionId();
8468 removalReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8470 /* Prints the Msg formed */
8471 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8473 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8475 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
8477 if(encRetVal.encoded == ENCODE_FAIL)
8479 DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
8480 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8485 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
8486 #ifdef DEBUG_ASN_PRINT
8487 for(int i=0; i< encBufSize; i++)
8489 printf("%x",encBuf[i]);
8493 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8495 DU_LOG("\nERROR --> E2AP : Sending removal request failed");
8501 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
8502 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
8506 /* Free all memory */
8507 FreeRemovalRequest(e2apMsg);
8512 /******************************************************************
8514 * @brief Deallocation of memory allocated by aper decoder
8515 * for Removal failure
8519 * Function : freeAperDecodingOfE2RemovalFailure
8521 * Functionality: Deallocation of memory allocated by aper decoder
8522 * for Removal failure
8524 * @params[in] Pointer to removalFailure
8527 * ****************************************************************/
8528 void freeAperDecodingOfE2RemovalFailure(E2RemovalFailure_t *removalFailure)
8534 if(removalFailure->protocolIEs.list.array)
8536 for(arrIdx=0; arrIdx<removalFailure->protocolIEs.list.count; arrIdx++)
8538 if(removalFailure->protocolIEs.list.array[arrIdx])
8540 free(removalFailure->protocolIEs.list.array[arrIdx]);
8543 free(removalFailure->protocolIEs.list.array);
8548 /******************************************************************
8550 * @brief Processes the E2 removal failure msg
8554 * Function : procE2RemovalFailure
8556 * Functionality: Processes the E2 removal failure msg
8559 * E2AP_PDU_t *e2apMsg
8563 * ****************************************************************/
8564 void ProcE2RemovalFailure(E2AP_PDU_t *e2apMsg)
8568 CauseE2_t *cause = NULLP;
8569 E2RemovalFailure_t *e2RemovalFailure=NULLP;
8571 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
8573 if(!e2RemovalFailure->protocolIEs.list.array)
8575 DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
8579 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
8581 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
8583 switch(e2RemovalFailure->protocolIEs.list.array[ieIdx]->id)
8585 case ProtocolIE_IDE2_id_TransactionID:
8587 transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8588 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8589 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8591 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8595 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8599 case ProtocolIE_IDE2_id_CauseE2:
8601 cause = &e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
8602 printE2ErrorCause(cause);
8607 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
8613 freeAperDecodingOfE2RemovalFailure(e2RemovalFailure);
8616 /******************************************************************
8618 * @brief Deallocation of memory allocated by aper decoder
8619 * for Removal failure
8623 * Function : freeAperDecodingOfE2RemovalResponse
8625 * Functionality: Deallocation of memory allocated by aper decoder
8626 * for Removal failure
8628 * @params[in] Pointer to removalResponse
8631 * ****************************************************************/
8632 void freeAperDecodingOfE2RemovalResponse(E2RemovalResponse_t *removalResponse)
8638 if(removalResponse->protocolIEs.list.array)
8640 for(arrIdx=0; arrIdx<removalResponse->protocolIEs.list.count; arrIdx++)
8642 if(removalResponse->protocolIEs.list.array[arrIdx])
8644 free(removalResponse->protocolIEs.list.array[arrIdx]);
8647 free(removalResponse->protocolIEs.list.array);
8652 /*******************************************************************
8654 * @brief process the E2 Removal Response
8658 * Function : ProcE2RemovalResponse
8660 * Functionality: Process E2 Removal Response
8663 * E2AP_PDU_t *e2apMsg
8666 ******************************************************************/
8668 void ProcE2RemovalResponse(E2AP_PDU_t *e2apMsg)
8672 E2RemovalResponse_t *removalRsp = NULLP;
8674 removalRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
8676 if(!removalRsp->protocolIEs.list.array)
8678 DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
8682 for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
8684 if(removalRsp->protocolIEs.list.array[ieIdx])
8686 switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
8688 case ProtocolIE_IDE2_id_TransactionID:
8690 transId = removalRsp->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8691 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8692 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8694 DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
8695 cmInetClose(&ricParams.sockFd);
8696 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8697 removeE2NodeInformation();
8701 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8707 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
8714 freeAperDecodingOfE2RemovalResponse(removalRsp);
8717 /*******************************************************************
8719 * @brief Deallocate the memory allocated for E2 Connection Update Failure
8723 * Function : FreeE2ConnectionUpdateFailure
8726 * - freeing the memory allocated for E2ConnectionUpdateFailure
8728 * @params[in] E2AP_PDU_t *e2apMsg
8729 * @return ROK - success
8732 * ****************************************************************/
8733 void FreeE2ConnectionUpdateFailure(E2AP_PDU_t *e2apMsg)
8736 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8738 if(e2apMsg != NULLP)
8740 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
8742 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8743 if(e2ConnectionUpdateFailure->protocolIEs.list.array)
8745 for(ieIdx=0; ieIdx < e2ConnectionUpdateFailure->protocolIEs.list.count; ieIdx++)
8747 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8749 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8751 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8753 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8757 /*******************************************************************
8759 * @brief Buld and send the E2 Connection Update Failure msg
8763 * Function : BuildAndSendE2ConnectionUpdateFailure
8766 * - Buld and send the E2 Connection Update Failure Message
8770 * @return ROK - success
8773 * ****************************************************************/
8775 uint8_t BuildAndSendE2ConnectionUpdateFailure(uint16_t transId, E2FailureCause failureCause)
8777 uint8_t ieIdx = 0, elementCnt = 0;
8778 uint8_t ret = RFAILED;
8779 E2AP_PDU_t *e2apMsg = NULLP;
8780 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8781 asn_enc_rval_t encRetVal; /* Encoder return value */
8783 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Failure Message\n");
8786 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8787 if(e2apMsg == NULLP)
8789 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8792 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
8794 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8795 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
8797 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8801 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
8802 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
8803 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure;
8804 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8807 e2ConnectionUpdateFailure->protocolIEs.list.count = elementCnt;
8808 e2ConnectionUpdateFailure->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateFailure_IEs_t *);
8809 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8810 if(!e2ConnectionUpdateFailure->protocolIEs.list.array)
8812 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8816 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
8818 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8819 if(!e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx])
8821 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8825 if(ieIdx < elementCnt)
8829 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8830 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8831 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_TransactionID;
8832 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8836 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
8837 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
8838 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_CauseE2;
8839 fillE2Cause(&e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, failureCause);
8841 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8843 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8845 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
8846 if(encRetVal.encoded == ENCODE_FAIL)
8848 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update failure structure (at %s)\n",\
8849 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8854 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Failure \n");
8855 for(int i=0; i< encBufSize; i++)
8857 DU_LOG("%x",encBuf[i]);
8862 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8864 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Failure");
8872 FreeE2ConnectionUpdateFailure(e2apMsg);
8876 /*******************************************************************
8878 * @brief fill E2 connection update item
8882 * Function : fillE2connectionUpdateItem
8884 * Functionality: fill E2 connection update item
8887 * E2connectionUpdate Item to be filled
8891 * @return ROK - success
8893 * ****************************************************************/
8895 uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId, uint32_t ipAddress, AssocUsage usage)
8897 CauseE2_t *cause=NULLP;
8898 TNLusage_t *tnlUsage=NULLP;
8899 E2FailureCause failureCause;
8900 TNLinformation_t *tnlInformation = NULLP;
8901 E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
8902 E2connectionSetupFailed_Item_t *connectionRemoveITem=NULLP;
8906 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8908 connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
8909 tnlInformation = &connectionModifyItem->tnlInformation;
8910 tnlUsage = &connectionModifyItem->tnlUsage;
8914 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8916 connectionRemoveITem = (E2connectionSetupFailed_Item_t*)connectionInfo;
8917 tnlInformation= &connectionRemoveITem->tnlInformation;
8918 cause = &connectionRemoveITem->cause;
8925 tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
8926 DU_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
8927 if(!tnlInformation->tnlAddress.buf)
8929 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8933 tnlInformation->tnlAddress.buf[3] = ipAddress & 0xFF;
8934 tnlInformation->tnlAddress.buf[2] = (ipAddress>> 8) & 0xFF;
8935 tnlInformation->tnlAddress.buf[1] = (ipAddress>> 16) & 0xFF;
8936 tnlInformation->tnlAddress.buf[0] = (ipAddress>> 24) & 0xFF;
8937 tnlInformation->tnlAddress.bits_unused = 0;
8941 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8946 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8948 failureCause.causeType = E2_TRANSPORT;
8949 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
8950 fillE2Cause(cause, failureCause);
8960 /*******************************************************************
8962 * @brief Build E2 connection modification list
8966 * Function :BuildE2ConnectionUpdateList
8968 * Functionality: Build E2 connection modification list
8971 * E2 connection update list to be filled
8972 * Count of E2 connection to be added in the list
8973 * Received list of E2 connection
8975 * @return ROK - success
8977 * ****************************************************************/
8979 uint8_t BuildE2ConnectionUpdateList(E2connectionUpdate_List_t *connectionSetupList, uint8_t count, E2ConnectionItem *tmpConnectionList)
8982 E2connectionUpdate_ItemIEs_t *connectionSetupItem=NULLP;
8984 connectionSetupList->list.count = count;
8986 connectionSetupList->list.size = connectionSetupList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
8987 DU_ALLOC(connectionSetupList->list.array, connectionSetupList->list.size);
8988 if(connectionSetupList->list.array)
8990 for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
8992 DU_ALLOC(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
8993 if(connectionSetupList->list.array[arrIdx] == NULLP)
8995 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8998 connectionSetupItem = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
8999 connectionSetupItem->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
9000 connectionSetupItem->criticality= CriticalityE2_ignore;
9001 connectionSetupItem->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
9002 if(fillE2connectionUpdateItem((PTR)&connectionSetupItem->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item,\
9003 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
9005 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
9013 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9019 /*******************************************************************
9021 * @brief Build E2 connection setup failed list
9025 * Function : BuildE2ConnectionSetupFailedList
9027 * Functionality: Build E2 connection setup failed list
9030 * E2 connection setup failed list to be filled
9031 * Count of E2 connection to be added in the list
9032 * Received list of E2 connection
9034 * @return ROK - success
9036 * ****************************************************************/
9038 uint8_t BuildE2ConnectionSetupFailedList(E2connectionSetupFailed_List_t *setupFailedList, uint8_t count, E2ConnectionItem *tmpConnectionList)
9041 E2connectionSetupFailed_ItemIEs_t *setupFailedItem=NULLP;
9043 setupFailedList->list.count = 1;
9045 setupFailedList->list.size = setupFailedList->list.count*sizeof(E2connectionSetupFailed_ItemIEs_t *);
9046 DU_ALLOC(setupFailedList->list.array, setupFailedList->list.size);
9047 if(setupFailedList->list.array)
9049 for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
9051 DU_ALLOC(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9052 if(setupFailedList->list.array[arrIdx] == NULLP)
9054 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9057 setupFailedItem = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
9058 setupFailedItem->id = ProtocolIE_IDE2_id_E2connectionSetupFailed_Item;
9059 setupFailedItem->criticality= CriticalityE2_ignore;
9060 setupFailedItem->value.present = E2connectionSetupFailed_ItemIEs__value_PR_E2connectionSetupFailed_Item;
9061 if(fillE2connectionUpdateItem((PTR)&setupFailedItem->value.choice.E2connectionSetupFailed_Item, ProtocolIE_IDE2_id_E2connectionSetupFailed_Item,\
9062 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
9064 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection failed to update item");
9072 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9078 /*******************************************************************
9080 * @brief Deallocate the memory allocated for E2 Connection
9085 * Function :FreeE2ConnectionUpdateAcknowledge
9088 * - freeing the memory allocated for E2 Connection
9091 * @params[in] E2AP_PDU_t *e2apMsg
9092 * @return ROK - success
9095 * ****************************************************************/
9097 void FreeE2ConnectionUpdateAcknowledge(E2AP_PDU_t *e2apMsg)
9099 uint8_t ieIdx =0, arrIdx=0;
9100 E2connectionUpdateAcknowledge_t *connectionUpdate = NULLP;
9101 E2connectionUpdate_List_t *connectionSetupList = NULLP;
9102 E2connectionSetupFailed_List_t *setupFailedList = NULLP;
9104 if(e2apMsg != NULLP)
9106 if(e2apMsg->choice.successfulOutcome != NULLP)
9108 connectionUpdate = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9109 if(connectionUpdate->protocolIEs.list.array)
9111 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9113 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9115 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9117 case ProtocolIE_IDE2_id_TransactionID:
9120 case ProtocolIE_IDE2_id_E2connectionSetup:
9122 connectionSetupList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9123 if(connectionSetupList->list.array)
9125 for(arrIdx = 0; arrIdx < connectionSetupList->list.count; arrIdx++)
9127 DU_FREE(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
9129 DU_FREE(connectionSetupList->list.array, connectionSetupList->list.size);
9134 case ProtocolIE_IDE2_id_E2connectionSetupFailed:
9136 setupFailedList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
9137 if(setupFailedList->list.array)
9139 for(arrIdx = 0; arrIdx < setupFailedList->list.count; arrIdx++)
9141 DU_FREE(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9143 DU_FREE(setupFailedList->list.array, setupFailedList->list.size);
9148 DU_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9151 DU_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
9153 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9155 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
9159 /*******************************************************************
9161 * @brief Buld and send the E2 Connection Update Acknowledge msg
9165 * Function : BuildAndSendE2ConnectionUpdateAcknowledge
9168 * - Buld and send the E2 Connection Update Acknowledge Message
9171 * List of E2 connection needs to fill in IE
9172 * @return ROK - success
9175 * ****************************************************************/
9177 uint8_t BuildAndSendE2ConnectionUpdateAcknowledge(uint16_t transId, E2ConnectionList connectionInfoList)
9179 uint8_t ieIdx = 0, elementCnt = 0;
9180 uint8_t ret = RFAILED;
9181 E2AP_PDU_t *e2apMsg = NULLP;
9182 asn_enc_rval_t encRetVal;
9183 E2connectionUpdateAcknowledge_t *e2ConnectionUpdateAcknowledge=NULLP;
9185 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Acknowledge Message\n");
9188 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
9189 if(e2apMsg == NULLP)
9191 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9194 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
9196 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9197 if(e2apMsg->choice.successfulOutcome == NULLP)
9199 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9203 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
9204 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
9205 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge;
9206 e2ConnectionUpdateAcknowledge = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9209 if(connectionInfoList.numOfE2ConnectionSetup)
9211 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9214 e2ConnectionUpdateAcknowledge->protocolIEs.list.count = elementCnt;
9215 e2ConnectionUpdateAcknowledge->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateAck_IEs_t*);
9216 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array, e2ConnectionUpdateAcknowledge->protocolIEs.list.size);
9217 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array)
9219 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9223 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
9225 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9226 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx])
9228 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9232 if(ieIdx < elementCnt)
9236 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
9237 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9238 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_TransactionID;
9239 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
9241 if(connectionInfoList.numOfE2ConnectionSetup)
9244 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetup;
9245 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9246 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionUpdate_List;
9247 if(BuildE2ConnectionUpdateList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List, \
9248 connectionInfoList.numOfE2ConnectionSetup, connectionInfoList.setupE2Connection) != ROK)
9250 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection setup list");
9255 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9258 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetupFailed;
9259 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9260 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionSetupFailed_List;
9261 if(BuildE2ConnectionSetupFailedList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List, \
9262 connectionInfoList.numOfE2ConnectionFailedToSetup, connectionInfoList.failedToSetupE2Connection) != ROK)
9264 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection failed to setup list");
9269 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
9271 memset(encBuf, 0, ENC_BUF_MAX_LEN);
9273 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
9274 if(encRetVal.encoded == ENCODE_FAIL)
9276 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update acknowledge failure structure (at %s)\n",\
9277 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9282 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Acknowledge \n");
9283 for(int i=0; i< encBufSize; i++)
9285 DU_LOG("%x",encBuf[i]);
9290 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
9292 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Acknowledge");
9300 FreeE2ConnectionUpdateAcknowledge(e2apMsg);
9304 /******************************************************************
9306 * @brief Deallocation of memory allocated by aper decoder for
9307 * E2 Connection Update
9311 * Function :freeAperDecodingOfE2ConnectionUpdate
9313 * Functionality: Deallocation of memory allocated by aper decoder for
9314 * E2 Connection Update
9316 * @params[in] Pointer to connectionUpdate
9319 * ****************************************************************/
9321 void freeAperDecodingOfE2ConnectionUpdate(E2connectionUpdate_t *connectionUpdate)
9323 uint8_t ieIdx =0, arrIdx=0;
9324 E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
9325 E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
9327 if(connectionUpdate->protocolIEs.list.array)
9329 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9331 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9333 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9335 case ProtocolIE_IDE2_id_TransactionID:
9338 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9340 connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9341 if(connectionToBeModifyList->list.array)
9343 for(arrIdx= 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
9345 free(connectionToBeModifyList->list.array[arrIdx]);
9347 free(connectionToBeModifyList->list.array);
9351 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9353 connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
9354 if(connectionToBeRemoveList->list.array)
9356 for(arrIdx= 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
9358 free(connectionToBeRemoveList->list.array[arrIdx]);
9360 free(connectionToBeRemoveList->list.array);
9365 free(connectionUpdate->protocolIEs.list.array[ieIdx]);
9368 free(connectionUpdate->protocolIEs.list.array);
9372 /*******************************************************************
9374 * @brief Handling of E2 connection modification Ie
9378 * Function : handleE2ConnectionModification
9380 * Functionality: Handling of E2 connection modification Ie
9383 * E2 Connection update list
9384 * E2 connection list which needs to be filled
9387 ******************************************************************/
9389 void handleE2ConnectionModification(E2connectionUpdate_List_t *connectionUpdateList, E2ConnectionList *connectionInfoList)
9391 uint32_t ipAddress=0;
9392 bool infoFound = false;
9393 uint8_t arrIdx=0,idx=0, count =0;
9394 E2connectionUpdate_ItemIEs_t *connectionModifyItem=NULLP;
9396 if(connectionUpdateList->list.array)
9398 for(arrIdx = 0; arrIdx < connectionUpdateList->list.count; arrIdx++)
9400 connectionModifyItem= (E2connectionUpdate_ItemIEs_t*)connectionUpdateList->list.array[arrIdx];
9401 bitStringToInt(&connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlInformation.tnlAddress, &ipAddress);
9402 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9404 /* If the TNL information is found in the data base, update the
9405 * information in the database */
9406 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9408 duCb.e2apDb.tnlAssoc[idx].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9414 /* If the TNL information is found in the data base, then add the
9415 * information in setupE2Connection array else add in failedToSetupE2Connection array */
9416 if(infoFound == true)
9418 count =connectionInfoList->numOfE2ConnectionSetup;
9419 connectionInfoList->setupE2Connection[count].ipV4Addr = duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr;
9420 connectionInfoList->setupE2Connection[count].usage = duCb.e2apDb.tnlAssoc[idx].usage;
9421 connectionInfoList->numOfE2ConnectionSetup++;
9425 count = connectionInfoList->numOfE2ConnectionFailedToSetup;
9426 connectionInfoList->failedToSetupE2Connection[count].ipV4Addr = ipAddress;
9427 connectionInfoList->failedToSetupE2Connection[count].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9428 connectionInfoList->numOfE2ConnectionFailedToSetup++;
9435 /*******************************************************************
9437 * @brief Handling of E2 connection removal Ie
9441 * Function : handleE2ConnectionRemoval
9443 * Functionality: Handling of E2 connection removal Ie
9446 * E2 Connection removal List
9449 ******************************************************************/
9451 void handleE2ConnectionRemoval(E2connectionUpdateRemove_List_t *connectionRemovalList)
9453 uint32_t ipAddress=0;
9454 uint8_t arrIdx=0,idx=0;
9455 E2connectionUpdateRemove_ItemIEs_t *connectionRemovalItem=NULLP;
9457 if(connectionRemovalList->list.array)
9459 for(arrIdx = 0; arrIdx < connectionRemovalList->list.count; arrIdx++)
9461 connectionRemovalItem= (E2connectionUpdateRemove_ItemIEs_t*)connectionRemovalList->list.array[arrIdx];
9462 bitStringToInt(&connectionRemovalItem->value.choice.E2connectionUpdateRemove_Item.tnlInformation.tnlAddress, &ipAddress);
9463 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9465 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9467 cmInetClose(&ricParams.sockFd);
9468 removeE2NodeInformation();
9477 /*******************************************************************
9479 * @brief Process e2 connection update received from RIC
9483 * Function : procE2ConnectionUpdate
9485 * Functionality: Process e2 connection update received from RIC
9487 * @param E2AP_PDU_t *e2apMsg
9490 ******************************************************************/
9492 void procE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
9495 uint16_t transId =0;
9496 bool invalidTransId = false, connectionFailedToUpdate=false;
9497 E2FailureCause failureCause;
9498 E2ConnectionList connectionInfoList;
9499 E2connectionUpdate_t *connectionUpdate=NULLP;
9501 DU_LOG("\nINFO --> E2AP : E2 connection update received");
9502 connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
9504 memset(&connectionInfoList, 0, sizeof(E2ConnectionList));
9505 for(arrIdx=0; arrIdx<connectionUpdate->protocolIEs.list.count; arrIdx++)
9507 switch(connectionUpdate->protocolIEs.list.array[arrIdx]->id)
9509 case ProtocolIE_IDE2_id_TransactionID:
9511 transId = connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
9514 failureCause.causeType = E2_PROTOCOL;
9515 failureCause.cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
9516 invalidTransId = true;
9521 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9523 handleE2ConnectionModification(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdate_List,\
9524 &connectionInfoList);
9525 if((connectionInfoList.numOfE2ConnectionSetup == 0) && (connectionInfoList.numOfE2ConnectionFailedToSetup > 0))
9527 failureCause.causeType = E2_TRANSPORT;
9528 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
9529 connectionFailedToUpdate =true;
9535 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9537 handleE2ConnectionRemoval(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdateRemove_List);
9543 DU_LOG("\nERROR --> E2AP : Invalid IE received[%ld]",connectionUpdate->protocolIEs.list.array[arrIdx]->id);
9548 if(invalidTransId == true || connectionFailedToUpdate ==true)
9552 if(invalidTransId == true || connectionFailedToUpdate == true)
9554 if(BuildAndSendE2ConnectionUpdateFailure(transId, failureCause) != ROK)
9556 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update failure");
9561 if(BuildAndSendE2ConnectionUpdateAcknowledge(transId, connectionInfoList) != ROK)
9563 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update ack");
9567 freeAperDecodingOfE2ConnectionUpdate(connectionUpdate);
9570 /*******************************************************************
9572 * @brief Free RIC Subscription action to be added list
9576 * Function : freeAperDecodingOfRicSubsActionToBeAdded
9578 * Functionality: Free the RIC Subscription action to be added list
9580 * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
9583 * ****************************************************************/
9584 void freeAperDecodingOfRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
9586 uint8_t elementIdx = 0;
9587 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
9589 if(subsDetails->list.array)
9591 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9593 if(subsDetails->list.array[elementIdx])
9595 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
9596 free(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf);
9597 free(subsDetails->list.array[elementIdx]);
9600 free(subsDetails->list.array);
9604 /*******************************************************************
9606 * @brief Deallocation of memory allocated by aper decoder for
9607 * RIC Subscription action to be removed list
9611 * Function : freeAperDecodingOfRicSubsActionToBeRemoved
9613 * Functionality: Free the RIC Subscription action to be removed list
9615 * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
9618 * ****************************************************************/
9619 void freeAperDecodingOfRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
9621 uint8_t elementIdx = 0;
9623 if(subsDetails->list.array)
9625 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9627 if(subsDetails->list.array[elementIdx])
9629 free(subsDetails->list.array[elementIdx]);
9632 free(subsDetails->list.array);
9636 /*******************************************************************
9638 * @brief Deallocation of memory allocated by aper decoder for
9639 * RIC Subscription action to be modify
9643 * Function : freeAperDecodingOfRicSubsActionToBeModified
9645 * Functionality: Free the RIC Subscription action to be modify
9647 * @params[in] RICactions_ToBeModifiedForModification_List_t List
9650 * ****************************************************************/
9651 void freeAperDecodingOfRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
9653 uint8_t elementIdx = 0;
9654 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
9656 if(subsDetails->list.array)
9658 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9660 if(subsDetails->list.array[elementIdx])
9662 actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx];
9663 if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
9665 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf);
9666 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition);
9668 free(subsDetails->list.array[elementIdx]);
9671 free(subsDetails->list.array);
9675 /*******************************************************************
9677 * @brief Deallocation of memory allocated by aper decoder for
9678 * RIC Subscription modification Request
9682 * Function freeAperDecodingOfRicSubsModificationReq
9684 * Functionality : Free RIC Subscription modification Request
9686 * @params[in] E2AP_PDU
9689 ******************************************************************/
9690 void freeAperDecodingOfRicSubsModificationReq(E2AP_PDU_t *e2apRicMsg)
9693 RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
9694 RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe;
9696 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
9698 if(ricSubscriptionModReq->protocolIEs.list.array)
9700 for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
9702 if(ricSubscriptionModReq->protocolIEs.list.array[idx])
9704 ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
9706 switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
9708 case ProtocolIE_IDE2_id_RICrequestID:
9711 case ProtocolIE_IDE2_id_RANfunctionID:
9714 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
9716 freeAperDecodingOfRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
9719 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
9721 freeAperDecodingOfRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
9724 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
9726 freeAperDecodingOfRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
9731 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
9737 free(ricSubscriptionModReq->protocolIEs.list.array[idx]);
9740 free(ricSubscriptionModReq->protocolIEs.list.array);
9743 /*******************************************************************
9745 * @brief Extract RIC Action to be added
9749 * Function : extractRicActionToBeAddedForModification
9751 * Functionality : This function :
9752 * - [Step -1] Traverse each AddedForModification item indexes.
9753 * - [Step -2] Add each action id related information in
9754 * RicSubscription Db.
9755 * - [Step -3] If failed to store then add action related info in
9756 * pending rsp's rejectedActionList.
9757 * - [Step -4] Else increment action added count
9758 * - [Step -5] If there is even 1 action that can be added,
9759 * return ROK, else RFAILED.
9761 * @params[in] RAN Function Database structure
9762 * RIC Subscription Info to be added to RAN function
9763 * RIC Action To Be AddedForModification List received from RIC
9765 * Pending Subs Mod Rsp Info
9766 * @return ROK - success
9769 ******************************************************************/
9770 uint8_t extractRicActionToBeAddedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9771 RICactions_ToBeAddedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9773 uint8_t actionAdded=0;
9774 CmLList *actionNode = NULLP;
9775 uint8_t actionIdx = 0;
9776 uint8_t ricActionId = 0;
9777 RICaction_ToBeAddedForModification_ItemIEs_t *actionItem = NULLP;
9779 if(actionList->list.array)
9781 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9784 actionItem =(RICaction_ToBeAddedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9785 switch(actionItem->id)
9787 case ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item:
9790 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeAddedForModification_Item,\
9791 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item, failureCause);
9796 subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].id = ricActionId;
9797 if(failureCause->causeType == E2_NOTHING)
9799 failureCause->causeType = E2_RIC_REQUEST;
9800 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
9802 memcpy(&subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].failureCause, \
9803 failureCause, sizeof(E2FailureCause));
9804 subsModRsp->addActionStatus.numOfRejectedActions++;
9814 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicAddedForModificationLst:%ld",actionItem->id);
9824 if(failureCause->causeType == E2_NOTHING)
9826 failureCause->causeType = E2_RIC_REQUEST;
9827 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
9832 /*******************************************************************
9834 * @brief Extract RIC Action to be Modified
9838 * Function : extractRicActionToBeModifiedForModification
9840 * Functionality : This function :
9841 * - [Step -1] Traverse each Modification item indexes.
9842 * - [Step -2] Find each action id related information in
9843 * RicSubscription Db.
9844 * - [Step -3] If not found store the action related info in pending
9845 * rsp's action rejected.
9846 * - [Step -4] If found store the new node in action seq list.
9847 * [Step -4.1] If action failed to store, add the action
9848 * info in pending subscription rsp's rejected list.
9849 * [Step -4.2] If action stored successfully, change the status
9850 * of added action to modified because action added as part of
9851 * ric subscription modification req.
9852 * - [Step -5] If there is even 1 action that can be modified,
9853 * return ROK, else RFAILED.
9855 * @params[in] RAN Function Database structure
9856 * RIC Subscription Info to be Modified to RAN function
9857 * RIC Action To Be ModifiedForModification List received from RIC
9859 * Pending Subs Mod Rsp Info
9860 * @return ROK - success
9863 ******************************************************************/
9864 uint8_t extractRicActionToBeModifiedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9865 RICactions_ToBeModifiedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9868 uint8_t actionIdx = 0;
9869 uint8_t actionFound=0;
9870 CmLList *actionNode = NULLP;
9871 ActionInfo *actionDb = NULLP;
9872 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
9874 if(actionList->list.array)
9876 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9879 actionItem =(RICaction_ToBeModifiedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9880 switch(actionItem->id)
9882 case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item:
9885 actionId=actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID;
9886 actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
9890 subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionDb->actionId;
9891 failureCause->causeType = E2_RIC_REQUEST;
9892 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
9893 memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \
9894 failureCause, sizeof(E2FailureCause));
9895 subsModRsp->modActionStatus.numOfRejectedActions++;
9901 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeModifiedForModification_Item,\
9902 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item, failureCause);
9907 subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionId;
9908 if(failureCause->causeType == E2_NOTHING)
9910 failureCause->causeType = E2_RIC_REQUEST;
9911 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
9913 memcpy(&subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \
9914 failureCause, sizeof(E2FailureCause));
9915 subsModRsp->addActionStatus.numOfRejectedActions++;
9920 actionDb = (ActionInfo*)actionNode->node;
9921 actionDb->action=CONFIG_MOD;
9929 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicModifiedForModificationLst:%ld",actionItem->id);
9942 /*******************************************************************
9944 * @brief Extract RIC Action to be Removed
9948 * Function : extractRicActionToBeRemovedForModification
9950 * Functionality : This function :
9951 * - [Step -1] Traverse each RemovedForModification item indexes.
9952 * - [Step -2] Find each action id related information in
9953 * RicSubscription Db.
9954 * - [Step -3] If not found store the action related info in pending
9955 * rsp's rejectedActionList.
9956 * - [Step -4] If found mark action's status CONFIG_DEL.
9957 * - [Step -5] If there is even 1 action that can be Removed,
9958 * return ROK, else RFAILED.
9960 * @params[in] RAN Function Database structure
9961 * RIC Subscription Info to be Removed to RAN function
9962 * RIC Action To Be RemovedForModification List received from RIC
9964 * Pending ric subs mod Rsp Info to store failure result
9965 * @return ROK - success
9968 ******************************************************************/
9969 uint8_t extractRicActionToBeRemovedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9970 RICactions_ToBeRemovedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9973 uint8_t actionIdx = 0;
9974 uint8_t actionFound=0;
9975 CmLList *actionNode = NULLP;
9976 ActionInfo *actionDb = NULLP;
9977 RICaction_ToBeRemovedForModification_ItemIEs_t *actionItem = NULLP;
9979 if(actionList->list.array)
9981 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9984 actionItem =(RICaction_ToBeRemovedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9985 switch(actionItem->id)
9987 case ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item:
9990 actionId = actionItem->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID;
9991 actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
9995 subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].id = actionDb->actionId;
9996 if(failureCause->causeType == E2_NOTHING)
9998 failureCause->causeType = E2_RIC_REQUEST;
9999 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
10001 memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].failureCause, \
10002 failureCause, sizeof(E2FailureCause));
10003 subsModRsp->removeActionStatus.numOfRejectedActions++;
10008 actionDb->action=CONFIG_DEL;
10014 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicRemovedForModificationLst:%ld",actionItem->id);
10027 /*******************************************************************
10029 * @brief Process RIC Subscription modification request
10033 * Function : procRicSubscriptionModificationRequest
10035 * Functionality: Process RIC subscription modification request.
10037 * @params[in] E2AP PDU
10040 ******************************************************************/
10041 void procRicSubscriptionModificationRequest(E2AP_PDU_t *e2apMsg)
10044 uint16_t ranFuncId = 0;
10045 RicRequestId ricReqId;
10046 E2FailureCause failureCause;
10047 bool procFailure = false;
10048 bool addActionIeProcessed=false;
10049 bool modActionIeProcessed =false;
10050 bool removeActionIeProcessed =false;
10051 CmLList *ricSubsNode = NULLP;
10052 RanFunction *ranFuncDb = NULLP;
10053 RicSubscription *ricSubsDb = NULLP;
10054 RICsubscriptionModificationRequest_t *ricSubsModifyReq = NULLP;
10055 RICsubscriptionModificationRequest_IEs_t *ricSubsModifyReqIe = NULLP;
10057 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Request", __func__);
10062 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
10066 if(!e2apMsg->choice.initiatingMessage)
10068 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
10072 ricSubsModifyReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
10073 for(ieIdx = 0; ieIdx < ricSubsModifyReq->protocolIEs.list.count; ieIdx++)
10075 if(!ricSubsModifyReq->protocolIEs.list.array[ieIdx])
10077 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
10081 ricSubsModifyReqIe = ricSubsModifyReq->protocolIEs.list.array[ieIdx];
10082 switch(ricSubsModifyReqIe->id)
10084 case ProtocolIE_IDE2_id_RICrequestID:
10086 memset(&ricReqId, 0, sizeof(RicRequestId));
10087 ricReqId.requestorId = ricSubsModifyReqIe->value.choice.RICrequestID.ricRequestorID;
10088 ricReqId.instanceId = ricSubsModifyReqIe->value.choice.RICrequestID.ricInstanceID;
10092 case ProtocolIE_IDE2_id_RANfunctionID:
10094 ranFuncId = ricSubsModifyReqIe->value.choice.RANfunctionID;
10095 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
10098 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
10099 procFailure = true;
10103 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
10106 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
10107 __func__, ricReqId.requestorId, ricReqId.instanceId);
10108 procFailure = true;
10111 memset(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp], 0, sizeof(PendingSubsModRspInfo));
10112 memcpy(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].requestId,
10113 &ricReqId, sizeof(RicRequestId));
10114 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].ranFuncId = ranFuncId;
10118 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
10120 if(extractRicActionToBeRemovedForModification(ranFuncDb, ricSubsDb,\
10121 &ricSubsModifyReqIe->value.choice.RICactions_ToBeRemovedForModification_List,\
10122 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10124 removeActionIeProcessed= true;
10129 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
10131 if(extractRicActionToBeModifiedForModification(ranFuncDb, ricSubsDb,\
10132 &ricSubsModifyReqIe->value.choice.RICactions_ToBeModifiedForModification_List,\
10133 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10135 modActionIeProcessed = true;
10139 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
10141 if(extractRicActionToBeAddedForModification(ranFuncDb, ricSubsDb,\
10142 &ricSubsModifyReqIe->value.choice.RICactions_ToBeAddedForModification_List,\
10143 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10145 addActionIeProcessed = true;
10151 } /* End of switch for Protocol IE Id */
10155 } /* End of for loop for Protocol IE list */
10160 if(!removeActionIeProcessed && !addActionIeProcessed && !modActionIeProcessed)
10162 BuildAndSendRicSubscriptionModificationFailure(ranFuncId, ricReqId, failureCause);
10166 if(duChkTmr((PTR)ricSubsDb, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR) == true)
10168 duStopTmr((PTR)ricSubsDb, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR);
10171 ricSubsDb->action = CONFIG_MOD;
10172 ranFuncDb->numPendingSubsModRsp++;
10174 /*If the remove-action ie is present, send a stats delete request;
10175 * otherwise, change removeActionCompleted to true in the pendingSubsModRspInfo. */
10176 if(removeActionIeProcessed)
10178 BuildAndSendStatsDeleteReq(ricSubsDb, false);
10182 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].removeActionCompleted = true;
10185 /*If the mod-action ie is present, send a stats modification request;
10186 * otherwise, change modActionCompleted to true in the pendingSubsModRspInfo. */
10187 if(modActionIeProcessed)
10189 BuildAndSendStatsModificationReq(ricSubsDb);
10193 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].modActionCompleted= true;
10196 /*If the add-action ie is present, send a stats add request;
10197 * otherwise, change addActionCompleted to true in the pendingSubsModRspInfo. */
10198 if(addActionIeProcessed)
10200 BuildAndSendStatsReq(ricSubsDb);
10204 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].addActionCompleted= true;
10209 freeAperDecodingOfRicSubsModificationReq(e2apMsg);
10212 /*******************************************************************
10213 * @brief Free RIC Subscription Modification Failure Message
10217 * Function : FreeRicSubscriptionModificationFailure
10219 * Functionality: Free RIC Subscription Modification Failure
10221 * @param E2AP Message PDU
10224 ******************************************************************/
10225 void FreeRicSubscriptionModificationFailure(E2AP_PDU_t *e2apMsg)
10228 RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
10232 if(e2apMsg->choice.unsuccessfulOutcome)
10234 ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
10235 if(ricSubsModFailure->protocolIEs.list.array)
10237 for(ieIdx = 0; ieIdx < ricSubsModFailure->protocolIEs.list.count; ieIdx++)
10239 DU_FREE(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
10241 DU_FREE(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
10243 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
10245 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
10248 /*******************************************************************
10250 * @brief Builds and Send RIC Subscription Modification Failure
10254 * Function : BuildAndSendRicSubscriptionModificationFailure
10256 * Functionality: Build and send RIC Subscription Modification Failure.
10262 * @return ROK - success
10263 * RFAILED - failure
10265 ******************************************************************/
10266 uint8_t BuildAndSendRicSubscriptionModificationFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
10268 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
10269 E2AP_PDU_t *e2apMsg = NULLP;
10270 RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
10271 RICsubscriptionModificationFailure_IEs_t *ricSubsModFailureIe = NULLP;
10272 asn_enc_rval_t encRetVal; /* Encoder return value */
10276 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Failure Message\n");
10278 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
10279 if(e2apMsg == NULLP)
10281 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10285 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
10286 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
10287 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
10289 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10292 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
10293 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
10294 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure;
10297 ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
10300 ricSubsModFailure->protocolIEs.list.count = elementCnt;
10301 ricSubsModFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationFailure_IEs_t *);
10303 DU_ALLOC(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
10304 if(ricSubsModFailure->protocolIEs.list.array == NULLP)
10306 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
10310 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
10312 DU_ALLOC(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
10313 if(ricSubsModFailure->protocolIEs.list.array[ieIdx] == NULLP)
10315 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
10316 __func__, ieIdx, __LINE__);
10320 if(ieIdx < elementCnt)
10324 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10325 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
10326 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10327 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RICrequestID;
10328 ricSubsModFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
10329 ricSubsModFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
10332 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10333 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
10334 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10335 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RANfunctionID;
10336 ricSubsModFailureIe->value.choice.RANfunctionID = ranFuncId;
10339 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10340 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
10341 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10342 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_CauseE2;
10343 fillE2Cause(&ricSubsModFailureIe->value.choice.CauseE2, failureCause);
10345 /* Prints the Msg formed */
10346 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
10347 memset(encBuf, 0, ENC_BUF_MAX_LEN);
10349 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
10350 if(encRetVal.encoded == ENCODE_FAIL)
10352 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Failure Message (at %s)\n",\
10353 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10358 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Failure Message \n");
10359 #ifdef DEBUG_ASN_PRINT
10360 for(int i=0; i< encBufSize; i++)
10362 printf("%x",encBuf[i]);
10367 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
10369 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Failure Message");
10377 FreeRicSubscriptionModificationFailure(e2apMsg);
10381 /*******************************************************************
10382 * @brief Free RIC Subscription Modification Response Message
10386 * Function : FreeRicSubscriptionModificationResponse
10388 * Functionality: Free RIC Subscription Modification Response
10390 * @param E2AP Message PDU
10393 ******************************************************************/
10394 void FreeRicSubscriptionModificationResponse(E2AP_PDU_t *e2apMsg)
10396 uint8_t ieIdx = 0, elementIdx=0;
10397 RICactions_AddedForModification_List_t *actionsAdded = NULLP;
10398 RICactions_RemovedForModification_List_t *actionsRemoved = NULLP;
10399 RICactions_ModifiedForModification_List_t *actionsModified = NULLP;
10400 RICactions_FailedToBeAddedForModification_List_t *actionsFailedToBeAdded = NULLP;
10401 RICactions_FailedToBeRemovedForModification_List_t *actionsFailedToBeRemoved = NULLP;
10402 RICactions_FailedToBeModifiedForModification_List_t *actionsFailedToBeModified = NULLP;
10404 RICsubscriptionModificationResponse_t *ricSubsModResponse = NULLP;
10408 if(e2apMsg->choice.successfulOutcome)
10410 ricSubsModResponse = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse;
10411 if(ricSubsModResponse->protocolIEs.list.array)
10413 for(ieIdx = 0; ieIdx < ricSubsModResponse->protocolIEs.list.count; ieIdx++)
10415 if(ricSubsModResponse->protocolIEs.list.array[ieIdx])
10417 switch(ricSubsModResponse->protocolIEs.list.array[ieIdx]->id)
10419 case ProtocolIE_IDE2_id_RANfunctionID:
10420 case ProtocolIE_IDE2_id_RICrequestID:
10422 case ProtocolIE_IDE2_id_RICactionsRemovedForModification_List:
10424 actionsRemoved = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_RemovedForModification_List;
10425 if(actionsRemoved->list.array)
10427 for(elementIdx = 0; elementIdx < actionsRemoved->list.count; elementIdx++)
10429 DU_FREE(actionsRemoved->list.array[elementIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t));
10431 DU_FREE(actionsRemoved->list.array, actionsRemoved->list.size);
10436 case ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List:
10438 actionsFailedToBeRemoved = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeRemovedForModification_List;
10439 if(actionsFailedToBeRemoved->list.array)
10441 for(elementIdx = 0; elementIdx < actionsFailedToBeRemoved->list.count; elementIdx++)
10443 DU_FREE(actionsFailedToBeRemoved->list.array[elementIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t));
10445 DU_FREE(actionsFailedToBeRemoved->list.array, actionsFailedToBeRemoved->list.size);
10449 case ProtocolIE_IDE2_id_RICactionsModifiedForModification_List:
10451 actionsModified = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_ModifiedForModification_List;
10452 if(actionsModified->list.array)
10454 for(elementIdx = 0; elementIdx < actionsModified->list.count; elementIdx++)
10456 DU_FREE(actionsModified->list.array[elementIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t));
10458 DU_FREE(actionsModified->list.array, actionsModified->list.size);
10462 case ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List:
10464 actionsFailedToBeModified = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeModifiedForModification_List;
10465 if(actionsFailedToBeModified->list.array)
10467 for(elementIdx = 0; elementIdx < actionsFailedToBeModified->list.count; elementIdx++)
10469 DU_FREE(actionsFailedToBeModified->list.array[elementIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t));
10471 DU_FREE(actionsFailedToBeModified->list.array, actionsFailedToBeModified->list.size);
10475 case ProtocolIE_IDE2_id_RICactionsAddedForModification_List:
10477 actionsAdded = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_AddedForModification_List;
10478 if(actionsAdded->list.array)
10480 for(elementIdx = 0; elementIdx < actionsAdded->list.count; elementIdx++)
10482 DU_FREE(actionsAdded->list.array[elementIdx], sizeof(RICaction_AddedForModification_ItemIEs_t));
10484 DU_FREE(actionsAdded->list.array, actionsAdded->list.size);
10488 case ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List:
10490 actionsFailedToBeAdded = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeAddedForModification_List;
10491 if(actionsFailedToBeAdded->list.array)
10493 for(elementIdx = 0; elementIdx < actionsFailedToBeAdded->list.count; elementIdx++)
10495 DU_FREE(actionsFailedToBeAdded->list.array[elementIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t));
10497 DU_FREE(actionsFailedToBeAdded->list.array, actionsFailedToBeAdded->list.size);
10502 DU_FREE(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t));
10505 DU_FREE(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size);
10507 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
10509 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
10513 /*******************************************************************
10515 * @brief Build Ric subscription action removed list
10519 * Function : BuildActionRemovedList
10521 * Functionality: Build Ric subs action removed list
10524 * RICactions_RemovedForModification_List_t to be filled
10525 * Num Of Action removed
10526 * Action removed list
10528 * @return ROK - success
10529 * RFAILED - failure
10531 ******************************************************************/
10533 uint8_t BuildActionRemovedList(RICactions_RemovedForModification_List_t *removedActionList, uint8_t numOfActionRemoved, uint8_t *actionRemoved)
10536 RICaction_RemovedForModification_ItemIEs_t *removedActionItemIe =NULLP;
10538 removedActionList->list.count = numOfActionRemoved;
10539 removedActionList->list.size = removedActionList->list.count * sizeof(RICaction_RemovedForModification_ItemIEs_t*);
10540 DU_ALLOC(removedActionList->list.array, removedActionList->list.size);
10541 if(!removedActionList->list.array)
10543 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10547 for(arrIdx = 0; arrIdx< removedActionList->list.count; arrIdx++)
10549 DU_ALLOC(removedActionList->list.array[arrIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t));
10550 if(!removedActionList->list.array[arrIdx])
10552 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10555 removedActionItemIe = (RICaction_RemovedForModification_ItemIEs_t*)removedActionList->list.array[arrIdx];
10556 removedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_RemovedForModification_Item;
10557 removedActionItemIe->criticality = CriticalityE2_ignore;
10558 removedActionItemIe->value.present = RICaction_RemovedForModification_ItemIEs__value_PR_RICaction_RemovedForModification_Item;
10559 removedActionItemIe->value.choice.RICaction_RemovedForModification_Item.ricActionID = actionRemoved[arrIdx];
10564 /*******************************************************************
10566 * @brief Build Ric subscription action added list
10570 * Function : BuildActionAddedList
10572 * Functionality: Build Ric subs action added list
10575 * RICactions_AddedForModification_List_t to be filled
10576 * Num Of Action added
10577 * Action added list
10579 * @return ROK - success
10580 * RFAILED - failure
10582 ******************************************************************/
10584 uint8_t BuildActionAddedList(RICactions_AddedForModification_List_t *addedActionList, uint8_t numOfActionAdded, uint8_t *actionAdded)
10587 RICaction_AddedForModification_ItemIEs_t *addedActionItemIe =NULLP;
10589 addedActionList->list.count = numOfActionAdded;
10590 addedActionList->list.size = addedActionList->list.count * sizeof(RICaction_AddedForModification_ItemIEs_t*);
10591 DU_ALLOC(addedActionList->list.array, addedActionList->list.size);
10592 if(!addedActionList->list.array)
10594 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10598 for(arrIdx = 0; arrIdx< addedActionList->list.count; arrIdx++)
10600 DU_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_AddedForModification_ItemIEs_t));
10601 if(!addedActionList->list.array[arrIdx])
10603 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10606 addedActionItemIe = (RICaction_AddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx];
10607 addedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_AddedForModification_Item;
10608 addedActionItemIe->criticality = CriticalityE2_ignore;
10609 addedActionItemIe->value.present = RICaction_AddedForModification_ItemIEs__value_PR_RICaction_AddedForModification_Item;
10610 addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID = actionAdded[arrIdx];
10615 /*******************************************************************
10617 * @brief Build Ric subscription action modified list
10621 * Function : BuildActionModifiedList
10623 * Functionality: Build Ric subs action modified list
10626 * RICactions_ModifiedForModification_List_t to be filled
10627 * Num Of Action modified
10628 * Action modified list
10630 * @return ROK - success
10631 * RFAILED - failure
10633 ******************************************************************/
10635 uint8_t BuildActionModifiedList(RICactions_ModifiedForModification_List_t *modifiedActionList, uint8_t numOfActionModified, uint8_t *actionModified)
10638 RICaction_ModifiedForModification_ItemIEs_t *modifiedActionItemIe =NULLP;
10640 modifiedActionList->list.count = numOfActionModified;
10641 modifiedActionList->list.size = modifiedActionList->list.count * sizeof(RICaction_ModifiedForModification_ItemIEs_t*);
10642 DU_ALLOC(modifiedActionList->list.array, modifiedActionList->list.size);
10643 if(!modifiedActionList->list.array)
10645 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10649 for(arrIdx = 0; arrIdx< modifiedActionList->list.count; arrIdx++)
10651 DU_ALLOC(modifiedActionList->list.array[arrIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t));
10652 if(!modifiedActionList->list.array[arrIdx])
10654 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10657 modifiedActionItemIe = (RICaction_ModifiedForModification_ItemIEs_t*)modifiedActionList->list.array[arrIdx];
10658 modifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ModifiedForModification_Item;
10659 modifiedActionItemIe->criticality = CriticalityE2_ignore;
10660 modifiedActionItemIe->value.present = RICaction_ModifiedForModification_ItemIEs__value_PR_RICaction_ModifiedForModification_Item;
10661 modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID = actionModified[arrIdx];
10666 /*******************************************************************
10668 * @brief Build Ric subscription action failed to be removed list
10672 * Function : BuildActionFailedToBeRemovedList
10674 * Functionality: Build Ric subs action failed to be removed list
10677 * RICactions_FailedToBeRemovedForModification_List_t to be filled
10678 * Num Of Action failed to be removed
10679 * Action failed to be removed list
10681 * @return ROK - success
10682 * RFAILED - failure
10684 ******************************************************************/
10686 uint8_t BuildActionFailedToBeRemovedList(RICactions_FailedToBeRemovedForModification_List_t *failedToBeRemovedActionList,\
10687 uint8_t numOfActionFailedToBeRemoved, RejectedAction *actionFailedToBeRemoved)
10690 RICaction_FailedToBeRemovedForModification_ItemIEs_t *failedToBeRemovedActionItemIe =NULLP;
10692 failedToBeRemovedActionList->list.count = numOfActionFailedToBeRemoved;
10693 failedToBeRemovedActionList->list.size = failedToBeRemovedActionList->list.count * sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t*);
10694 DU_ALLOC(failedToBeRemovedActionList->list.array, failedToBeRemovedActionList->list.size);
10695 if(!failedToBeRemovedActionList->list.array)
10697 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10701 for(arrIdx = 0; arrIdx< failedToBeRemovedActionList->list.count; arrIdx++)
10703 DU_ALLOC(failedToBeRemovedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t));
10704 if(!failedToBeRemovedActionList->list.array[arrIdx])
10706 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10709 failedToBeRemovedActionItemIe = (RICaction_FailedToBeRemovedForModification_ItemIEs_t*)failedToBeRemovedActionList->list.array[arrIdx];
10710 failedToBeRemovedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeRemovedForModification_Item;
10711 failedToBeRemovedActionItemIe->criticality = CriticalityE2_ignore;
10712 failedToBeRemovedActionItemIe->value.present = RICaction_FailedToBeRemovedForModification_ItemIEs__value_PR_RICaction_FailedToBeRemovedForModification_Item;
10713 failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID = actionFailedToBeRemoved[arrIdx].id;
10714 fillE2Cause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause, actionFailedToBeRemoved[arrIdx].failureCause);
10719 /*******************************************************************
10721 * @brief Build Ric subscription action failed to be modified list
10725 * Function : BuildActionFailedToBeModifiedList
10727 * Functionality: Build Ric subs action failed to be modified list
10730 * RICactions_FailedToBeModifiedForModification_List_t to be filled
10731 * Num Of Action failed to be modified
10732 * Action failed to be modified list
10734 * @return ROK - success
10735 * RFAILED - failure
10737 ******************************************************************/
10739 uint8_t BuildActionFailedToBeModifiedList(RICactions_FailedToBeModifiedForModification_List_t *failedToBeModifiedActionList,\
10740 uint8_t numOfActionFailedToBeModified, RejectedAction *actionFailedToBeModified)
10743 RICaction_FailedToBeModifiedForModification_ItemIEs_t *failedToBeModifiedActionItemIe =NULLP;
10745 failedToBeModifiedActionList->list.count = numOfActionFailedToBeModified;
10746 failedToBeModifiedActionList->list.size = failedToBeModifiedActionList->list.count * sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t*);
10747 DU_ALLOC(failedToBeModifiedActionList->list.array, failedToBeModifiedActionList->list.size);
10748 if(!failedToBeModifiedActionList->list.array)
10750 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10754 for(arrIdx = 0; arrIdx< failedToBeModifiedActionList->list.count; arrIdx++)
10756 DU_ALLOC(failedToBeModifiedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t));
10757 if(!failedToBeModifiedActionList->list.array[arrIdx])
10759 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10762 failedToBeModifiedActionItemIe = (RICaction_FailedToBeModifiedForModification_ItemIEs_t*)failedToBeModifiedActionList->list.array[arrIdx];
10763 failedToBeModifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeModifiedForModification_Item;
10764 failedToBeModifiedActionItemIe->criticality = CriticalityE2_ignore;
10765 failedToBeModifiedActionItemIe->value.present = RICaction_FailedToBeModifiedForModification_ItemIEs__value_PR_RICaction_FailedToBeModifiedForModification_Item;
10766 failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID = actionFailedToBeModified[arrIdx].id;
10767 fillE2Cause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause, actionFailedToBeModified[arrIdx].failureCause);
10772 /*******************************************************************
10774 * @brief Build Ric subscription action failed to be added list
10778 * Function : BuildActionFailedToBeAddedList
10780 * Functionality: Build Ric subs action failed to be added list
10783 * RICactions_FailedToBeAddedForModification_List_t to be filled
10784 * Num Of Action failed to be added
10785 * Action failed to be added list
10787 * @return ROK - success
10788 * RFAILED - failure
10790 ******************************************************************/
10792 uint8_t BuildActionFailedToBeAddedList(RICactions_FailedToBeAddedForModification_List_t *failedToBeAddedActionList, uint8_t numOfActionFailedToBeAdded, RejectedAction *actionFailedToBeAdded)
10795 RICaction_FailedToBeAddedForModification_ItemIEs_t *failedToBeAddedActionItemIe =NULLP;
10797 failedToBeAddedActionList->list.count = numOfActionFailedToBeAdded;
10798 failedToBeAddedActionList->list.size = failedToBeAddedActionList->list.count * sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t*);
10799 DU_ALLOC(failedToBeAddedActionList->list.array, failedToBeAddedActionList->list.size);
10800 if(!failedToBeAddedActionList->list.array)
10802 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10806 for(arrIdx = 0; arrIdx< failedToBeAddedActionList->list.count; arrIdx++)
10808 DU_ALLOC(failedToBeAddedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t));
10809 if(!failedToBeAddedActionList->list.array[arrIdx])
10811 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10814 failedToBeAddedActionItemIe = (RICaction_FailedToBeAddedForModification_ItemIEs_t*)failedToBeAddedActionList->list.array[arrIdx];
10815 failedToBeAddedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeAddedForModification_Item;
10816 failedToBeAddedActionItemIe->criticality = CriticalityE2_ignore;
10817 failedToBeAddedActionItemIe->value.present = RICaction_FailedToBeAddedForModification_ItemIEs__value_PR_RICaction_FailedToBeAddedForModification_Item;
10818 failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.ricActionID = actionFailedToBeAdded[arrIdx].id;
10819 fillE2Cause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause, actionFailedToBeAdded[arrIdx].failureCause);
10824 /*******************************************************************
10826 * @brief Builds and Send RIC Subscription Modification Response
10830 * Function : BuildAndSendRicSubscriptionModificationResponse
10832 * Functionality: Build and send RIC Subscription Modification Response.
10835 * PendingSubsModRspInfo
10836 * @return ROK - success
10837 * RFAILED - failure
10839 ******************************************************************/
10840 uint8_t BuildAndSendRicSubscriptionModificationResponse(PendingSubsModRspInfo *pendingSubsModRsp)
10842 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
10843 E2AP_PDU_t *e2apMsg = NULLP;
10844 RICsubscriptionModificationResponse_t *ricSubsModResponse = NULLP;
10845 RICsubscriptionModificationResponse_IEs_t *ricSubsModResponseIe = NULLP;
10846 asn_enc_rval_t encRetVal; /* Encoder return value */
10850 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Response Message\n");
10852 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
10853 if(e2apMsg == NULLP)
10855 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10859 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
10860 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
10861 if(e2apMsg->choice.successfulOutcome == NULLP)
10863 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10866 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
10867 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
10868 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationResponse;
10871 ricSubsModResponse = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse;
10874 if(pendingSubsModRsp->removeActionStatus.numOfAcceptedActions)
10876 if(pendingSubsModRsp->addActionStatus.numOfAcceptedActions)
10878 if(pendingSubsModRsp->modActionStatus.numOfAcceptedActions)
10880 if(pendingSubsModRsp->removeActionStatus.numOfRejectedActions)
10882 if(pendingSubsModRsp->addActionStatus.numOfRejectedActions)
10884 if(pendingSubsModRsp->modActionStatus.numOfRejectedActions)
10887 ricSubsModResponse->protocolIEs.list.count = elementCnt;
10888 ricSubsModResponse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationResponse_IEs_t *);
10890 DU_ALLOC(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size);
10891 if(ricSubsModResponse->protocolIEs.list.array == NULLP)
10893 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10897 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
10899 DU_ALLOC(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t));
10900 if(ricSubsModResponse->protocolIEs.list.array[ieIdx] == NULLP)
10902 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10906 if(ieIdx < elementCnt)
10910 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10911 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICrequestID;
10912 ricSubsModResponseIe->criticality = CriticalityE2_reject;
10913 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICrequestID;
10914 ricSubsModResponseIe->value.choice.RICrequestID.ricRequestorID= pendingSubsModRsp->requestId.requestorId;
10915 ricSubsModResponseIe->value.choice.RICrequestID.ricInstanceID = pendingSubsModRsp->requestId.instanceId;
10918 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10919 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RANfunctionID;
10920 ricSubsModResponseIe->criticality = CriticalityE2_reject;
10921 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RANfunctionID;
10922 ricSubsModResponseIe->value.choice.RANfunctionID = pendingSubsModRsp->ranFuncId;
10924 if(pendingSubsModRsp->removeActionStatus.numOfAcceptedActions)
10927 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10928 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsRemovedForModification_List;
10929 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10930 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_RemovedForModification_List;
10931 if(BuildActionRemovedList(&ricSubsModResponseIe->value.choice.RICactions_RemovedForModification_List,\
10932 pendingSubsModRsp->removeActionStatus.numOfAcceptedActions, pendingSubsModRsp->removeActionStatus.acceptedActionList) != ROK)
10934 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10939 if(pendingSubsModRsp->removeActionStatus.numOfRejectedActions)
10942 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10943 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List;
10944 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10945 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeRemovedForModification_List;
10946 if(BuildActionFailedToBeRemovedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeRemovedForModification_List,\
10947 pendingSubsModRsp->removeActionStatus.numOfRejectedActions, pendingSubsModRsp->removeActionStatus.rejectedActionList) != ROK)
10949 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10954 if(pendingSubsModRsp->modActionStatus.numOfAcceptedActions)
10957 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10958 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsModifiedForModification_List;
10959 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10960 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_ModifiedForModification_List;
10961 if(BuildActionModifiedList(&ricSubsModResponseIe->value.choice.RICactions_ModifiedForModification_List,\
10962 pendingSubsModRsp->modActionStatus.numOfAcceptedActions, pendingSubsModRsp->modActionStatus.acceptedActionList) != ROK)
10964 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10969 if(pendingSubsModRsp->modActionStatus.numOfRejectedActions)
10972 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10973 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List;
10974 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10975 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeModifiedForModification_List;
10976 if(BuildActionFailedToBeModifiedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeModifiedForModification_List,\
10977 pendingSubsModRsp->modActionStatus.numOfRejectedActions, pendingSubsModRsp->modActionStatus.rejectedActionList) != ROK)
10979 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10984 if(pendingSubsModRsp->addActionStatus.numOfAcceptedActions)
10987 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10988 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsAddedForModification_List;
10989 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10990 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_AddedForModification_List;
10991 if(BuildActionAddedList(&ricSubsModResponseIe->value.choice.RICactions_AddedForModification_List,\
10992 pendingSubsModRsp->addActionStatus.numOfAcceptedActions, pendingSubsModRsp->addActionStatus.acceptedActionList) != ROK)
10994 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10999 if(pendingSubsModRsp->addActionStatus.numOfRejectedActions)
11002 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
11003 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List;
11004 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
11005 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeAddedForModification_List;
11006 if(BuildActionFailedToBeAddedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeAddedForModification_List,\
11007 pendingSubsModRsp->addActionStatus.numOfRejectedActions, pendingSubsModRsp->addActionStatus.rejectedActionList) != ROK)
11009 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
11014 /* Prints the Msg formed */
11015 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
11016 memset(encBuf, 0, ENC_BUF_MAX_LEN);
11018 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
11019 if(encRetVal.encoded == ENCODE_FAIL)
11021 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Response Message (at %s)\n",\
11022 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11027 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Response Message \n");
11028 #ifdef DEBUG_ASN_PRINT
11029 for(int i=0; i< encBufSize; i++)
11031 printf("%x",encBuf[i]);
11036 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
11038 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Response Message");
11046 FreeRicSubscriptionModificationResponse(e2apMsg);
11050 /*******************************************************************
11052 * @brief Handles received E2AP message and sends back response
11056 * Function : E2APMsgHdlr
11059 * - Decodes received E2AP control message
11060 * - Prepares response message, encodes and sends to SCTP
11063 * @return ROK - success
11064 * RFAILED - failure
11066 * ****************************************************************/
11067 void E2APMsgHdlr(Buffer *mBuf)
11070 char *recvBuf = NULLP;
11072 MsgLen recvBufLen =0;
11073 E2AP_PDU_t *e2apMsg = NULLP;
11074 asn_dec_rval_t rval ={0}; /* Decoder return value */
11075 E2AP_PDU_t e2apasnmsg={0} ;
11077 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
11078 ODU_PRINT_MSG(mBuf, 0,0);
11080 /* Copy mBuf into char array to decode it */
11081 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
11082 DU_ALLOC(recvBuf, (Size)recvBufLen);
11084 if(recvBuf == NULLP)
11086 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
11089 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
11091 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
11095 #ifdef DEBUG_ASN_PRINT
11096 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
11097 for(i=0; i< recvBufLen; i++)
11099 printf("%x",recvBuf[i]);
11103 /* Decoding flat buffer into E2AP messsage */
11104 e2apMsg = &e2apasnmsg;
11105 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
11107 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
11108 DU_FREE(recvBuf, (Size)recvBufLen);
11110 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11112 DU_LOG("\nERROR --> E2AP : ASN decode failed");
11116 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
11118 switch(e2apMsg->present)
11120 case E2AP_PDU_PR_unsuccessfulOutcome:
11122 switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
11124 case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
11126 procE2SetupFailure(e2apMsg);
11129 case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure:
11131 procE2NodeConfigUpdateFailure(e2apMsg);
11134 case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure:
11136 procRicServiceUpdateFailure(e2apMsg);
11139 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse:
11141 procRicSubscriptionModificationRefuse(e2apMsg);
11144 case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
11146 ProcE2RemovalFailure(e2apMsg);
11151 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
11152 e2apMsg->choice.unsuccessfulOutcome->value.present);
11156 free(e2apMsg->choice.unsuccessfulOutcome);
11159 case E2AP_PDU_PR_successfulOutcome:
11161 switch(e2apMsg->choice.successfulOutcome->value.present)
11163 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
11167 procE2SetupRsp(e2apMsg);
11171 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
11173 procResetResponse(e2apMsg);
11176 case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge:
11178 procRicServiceUpdateAck(e2apMsg);
11181 case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm:
11183 procRicSubscriptionModificationConfirm(e2apMsg);
11186 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
11188 procE2NodeConfigUpdateAck(e2apMsg);
11191 case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
11193 ProcE2RemovalResponse(e2apMsg);
11198 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
11199 e2apMsg->choice.successfulOutcome->value.present);
11202 }/* End of switch(successfulOutcome) */
11203 free(e2apMsg->choice.successfulOutcome);
11207 case E2AP_PDU_PR_initiatingMessage:
11209 switch(e2apMsg->choice.initiatingMessage->value.present)
11211 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
11213 procRicSubscriptionRequest(e2apMsg);
11216 case InitiatingMessageE2__value_PR_RICserviceQuery:
11218 procRicServiceQuery(e2apMsg);
11221 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
11223 DU_LOG("\nINFO --> E2AP : Error indication received");
11226 case InitiatingMessageE2__value_PR_ResetRequestE2:
11228 DU_LOG("\nINFO --> E2AP : Reset request received");
11229 procE2ResetRequest(e2apMsg);
11232 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest:
11234 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Request received");
11235 procRicSubscriptionDeleteRequest(e2apMsg);
11238 case InitiatingMessageE2__value_PR_E2RemovalRequest:
11240 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
11241 procE2RemovalRequest(e2apMsg);
11244 case InitiatingMessageE2__value_PR_E2connectionUpdate:
11246 DU_LOG("\nINFO --> E2AP : E2 coneection update received");
11247 procE2ConnectionUpdate(e2apMsg);
11250 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest:
11252 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Request received");
11253 procRicSubscriptionModificationRequest(e2apMsg);
11258 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
11259 e2apMsg->choice.initiatingMessage->value.present);
11262 }/* End of switch(initiatingMessage) */
11263 free(e2apMsg->choice.initiatingMessage);
11268 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
11273 }/* End of switch(e2apMsg->present) */
11275 } /* End of E2APMsgHdlr */
11277 /**********************************************************************
11279 **********************************************************************/