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"
66 /*******************************************************************
68 * @brief Fill E2 Failure Cause
72 * Function : fillE2Cause
74 * Functionality: Fill E2 Failure Cause
76 * @params[in] E2 Cause pointer to be filled in
77 * E2 Cause to be filled from
80 ******************************************************************/
81 void fillE2Cause(CauseE2_t *e2Cause, E2FailureCause failureCause)
83 e2Cause->present = failureCause.causeType;
84 switch(e2Cause->present)
86 case CauseE2_PR_ricRequest:
88 e2Cause->choice.ricRequest = failureCause.cause;
91 case CauseE2_PR_ricService:
93 e2Cause->choice.ricService = failureCause.cause;
96 case CauseE2_PR_e2Node:
98 e2Cause->choice.e2Node = failureCause.cause;
101 case CauseE2_PR_transport:
103 e2Cause->choice.transport = failureCause.cause;
106 case CauseE2_PR_protocol:
108 e2Cause->choice.protocol = failureCause.cause;
111 case CauseE2_PR_misc:
113 e2Cause->choice.misc = failureCause.cause;
116 case CauseE2_PR_NOTHING:
122 /*******************************************************************
124 * @brief Printing Type and Cause of failure
128 * Function : printE2ErrorCause
130 * Functionality: Printing Type and Cause of failure
132 * @params[in] E2 Cause
135 ******************************************************************/
136 void printE2ErrorCause(CauseE2_t *cause)
138 switch(cause->present)
140 case CauseE2_PR_ricRequest:
142 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Request", cause->choice.ricRequest);
145 case CauseE2_PR_ricService:
147 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Service", cause->choice.ricService);
150 case CauseE2_PR_e2Node:
152 DU_LOG("Failure_Type [%s] Cause [%ld]", "E2_Node", cause->choice.e2Node);
155 case CauseE2_PR_transport:
157 DU_LOG("Failure_Type [%s] Cause [%ld]", "Transport", cause->choice.transport);
160 case CauseE2_PR_protocol:
162 DU_LOG("Failure_Type [%s] Cause [%ld]", "Protocol", cause->choice.protocol);
165 case CauseE2_PR_misc:
167 DU_LOG("Failure_Type [%s] Cause [%ld]", "Miscellaneous", cause->choice.misc);
172 DU_LOG("Failure_Type and Cause unknown");
178 /*******************************************************************
180 * @brief Deallocate the memory allocated for E2 Removal Failure
184 * Function : FreeE2RemovalFailure
187 * - freeing the memory allocated for E2RemovalFailure
189 * @params[in] E2AP_PDU_t *e2apMsg
190 * @return ROK - success
193 * ****************************************************************/
194 void FreeE2RemovalFailure(E2AP_PDU_t *e2apMsg)
197 E2RemovalFailure_t *e2RemovalFailure=NULLP;
201 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
203 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
204 if(e2RemovalFailure->protocolIEs.list.array)
206 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
208 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
210 DU_FREE(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
213 DU_FREE(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
215 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
217 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
221 /*******************************************************************
223 * @brief Buld and send the E2 Removal Failure msg
227 * Function : BuildAndSendE2RemovalFailure
230 * - Buld and send the E2 Removal Failure Message
231 * @params[in] Trans Id
232 * @return ROK - success
235 * ****************************************************************/
237 uint8_t BuildAndSendRemovalFailure(uint16_t transId, E2FailureCause failureCause)
239 uint8_t ieIdx = 0, elementCnt = 0;
240 uint8_t ret = RFAILED;
241 E2AP_PDU_t *e2apMsg = NULLP;
242 E2RemovalFailure_t *e2RemovalFailure=NULLP;
243 asn_enc_rval_t encRetVal; /* Encoder return value */
245 DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
248 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
251 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
254 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
256 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
257 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
259 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
263 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
264 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
265 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure;
266 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
269 e2RemovalFailure->protocolIEs.list.count = elementCnt;
270 e2RemovalFailure->protocolIEs.list.size = elementCnt * sizeof(E2RemovalFailureIEs_t *);
271 DU_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
272 if(!e2RemovalFailure->protocolIEs.list.array)
274 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
278 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
280 DU_ALLOC(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
281 if(!e2RemovalFailure->protocolIEs.list.array[ieIdx])
283 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
287 if(ieIdx < elementCnt)
291 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
292 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
293 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = E2RemovalFailureIEs__value_PR_TransactionID;
294 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
298 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
299 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
300 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
301 fillE2Cause(&e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, failureCause);
303 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
305 memset(encBuf, 0, ENC_BUF_MAX_LEN);
307 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
308 if(encRetVal.encoded == ENCODE_FAIL)
310 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
311 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
316 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
317 for(int i=0; i< encBufSize; i++)
319 DU_LOG("%x",encBuf[i]);
324 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
326 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Failure");
334 FreeE2RemovalFailure(e2apMsg);
338 /*******************************************************************
340 * @brief Deallocate the memory allocated for E2 Removal Response
344 * Function : FreeE2RemovalResponse
347 * - freeing the memory allocated for E2RemovalResponse
349 * @params[in] E2AP_PDU_t *e2apMsg
350 * @return ROK - success
353 * ****************************************************************/
354 void FreeE2RemovalResponse(E2AP_PDU_t *e2apMsg)
357 E2RemovalResponse_t *e2RemovalResponse=NULLP;
361 if(e2apMsg->choice.successfulOutcome != NULLP)
363 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
364 if(e2RemovalResponse->protocolIEs.list.array)
366 for(ieIdx=0; ieIdx < e2RemovalResponse->protocolIEs.list.count; ieIdx++)
368 if(e2RemovalResponse->protocolIEs.list.array[ieIdx])
370 DU_FREE(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
373 DU_FREE(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
375 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
377 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
381 /*******************************************************************
383 * @brief Buld and send the E2 Removal Response msg
387 * Function : BuildAndSendE2RemovalResponse
390 * - Buld and send the E2 Removal Response Message
391 * @params[in] Trans Id
392 * @return ROK - success
395 * ****************************************************************/
396 uint8_t BuildAndSendRemovalResponse(uint16_t transId)
398 uint8_t ieIdx = 0, elementCnt = 0;
399 uint8_t ret = RFAILED;
400 E2AP_PDU_t *e2apMsg = NULLP;
401 E2RemovalResponse_t *e2RemovalResponse=NULLP;
402 asn_enc_rval_t encRetVal; /* Encoder return value */
404 DU_LOG("\nINFO --> E2AP : Building E2 Removal Response Message\n");
407 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
410 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
413 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
415 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
416 if(e2apMsg->choice.successfulOutcome == NULLP)
418 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
422 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
423 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
424 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2RemovalResponse;
425 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
428 e2RemovalResponse->protocolIEs.list.count = elementCnt;
429 e2RemovalResponse->protocolIEs.list.size = elementCnt * sizeof(E2RemovalResponseIEs_t *);
430 DU_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
431 if(!e2RemovalResponse->protocolIEs.list.array)
433 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
437 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
439 DU_ALLOC(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
440 if(!e2RemovalResponse->protocolIEs.list.array[ieIdx])
442 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
446 if(ieIdx < elementCnt)
450 e2RemovalResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
451 e2RemovalResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
452 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.present = E2RemovalResponseIEs__value_PR_TransactionID;
453 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
455 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
457 memset(encBuf, 0, ENC_BUF_MAX_LEN);
459 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
460 if(encRetVal.encoded == ENCODE_FAIL)
462 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
463 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
468 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
469 for(int i=0; i< encBufSize; i++)
471 DU_LOG("%x",encBuf[i]);
476 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
478 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Response");
486 FreeE2RemovalResponse(e2apMsg);
490 /******************************************************************
492 * @brief Deallocation of memory allocated by aper decoder for Removal req
496 * Function : freeAperDecodingOfE2RemovalReq
498 * Functionality: Deallocation of memory allocated by aper decoder for
501 * @params[in] Pointer to removalReq
504 * ****************************************************************/
505 void freeAperDecodingOfE2RemovalReq(E2RemovalRequest_t *removalReq)
511 if(removalReq->protocolIEs.list.array)
513 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
515 if(removalReq->protocolIEs.list.array[arrIdx])
517 free(removalReq->protocolIEs.list.array[arrIdx]);
520 free(removalReq->protocolIEs.list.array);
525 /*******************************************************************
527 * @brief Process Removal req received from RIC
531 * Function : procE2RemovalRequest
533 * Functionality: Process Removal req received from RIC
535 * @param E2AP_PDU_t *e2apMsg
538 ******************************************************************/
540 void procE2RemovalRequest(E2AP_PDU_t *e2apMsg)
544 E2FailureCause failureCause;
545 E2RemovalRequest_t *removalReq=NULLP;
547 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
548 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
550 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
552 switch(removalReq->protocolIEs.list.array[arrIdx]->id)
554 case ProtocolIE_IDE2_id_TransactionID:
556 transId = removalReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
561 DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
567 if(transId>=0 && transId<=255)
569 if(BuildAndSendRemovalResponse(transId) != ROK)
571 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
576 failureCause.causeType = E2_PROTOCOL;
577 failureCause.cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
579 if(BuildAndSendRemovalFailure(transId, failureCause) != ROK)
581 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
584 freeAperDecodingOfE2RemovalReq(removalReq);
587 /*******************************************************************
589 * @brief Free the ErrorIndication Message
593 * Function : FreeRicIndication
595 * Functionality: Free the ErrorIndication Message
598 * E2AP_PDU is to freed
601 ******************************************************************/
602 void FreeErrorIndication(E2AP_PDU_t *e2apMsg)
605 ErrorIndicationE2_t *errorIndicationMsg= NULLP;
609 if(e2apMsg->choice.initiatingMessage != NULLP)
611 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
612 if(errorIndicationMsg!= NULLP)
614 if(errorIndicationMsg->protocolIEs.list.array != NULLP)
616 for(arrIdx=0; arrIdx<errorIndicationMsg->protocolIEs.list.count; arrIdx++)
618 DU_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t));
620 DU_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size);
623 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
625 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
629 /*******************************************************************
631 * @brief Builds and Send the ErrorIndication Message
635 * Function : BuildAndSendErrorIndication
637 * Functionality:Fills the ErrorIndication Message
644 * @return ROK - success
647 ******************************************************************/
649 uint8_t BuildAndSendErrorIndication(uint16_t transId, RicRequestId requestId, uint16_t ranFuncId, E2FailureCause failureCause)
651 uint8_t elementCnt =0, arrIdx=0, ret = RFAILED;
652 E2AP_PDU_t *e2apMsg = NULLP;
653 ErrorIndicationE2_t *errorIndicationMsg=NULLP;
654 asn_enc_rval_t encRetVal; /* Encoder return value */
658 DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
660 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
663 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
667 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
668 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
669 if(e2apMsg->choice.initiatingMessage == NULLP)
671 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
674 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
675 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
676 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2;
678 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
680 /* Element count is 2 for TransactionID/RICrequestID and Cause.
681 * If the RAN function id is present, the count will be increased.*/
688 errorIndicationMsg->protocolIEs.list.count = elementCnt;
689 errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*);
691 /* Initialize the E2Setup members */
692 DU_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
693 if(errorIndicationMsg->protocolIEs.list.array == NULLP)
695 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
699 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
701 DU_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
702 if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
704 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array [%d] elements in %s at line %d", arrIdx, __func__, __LINE__);
708 if(arrIdx < elementCnt)
713 if(transId >=0 && transId<=255)
716 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
717 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
718 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID;
719 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
724 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID;
725 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
726 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID;
727 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId;
728 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
733 /* RAN Function ID */
735 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID;
736 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
737 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID;
738 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId;
743 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
744 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
745 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
746 fillE2Cause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, failureCause);
748 /* Prints the Msg formed */
749 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
750 memset(encBuf, 0, ENC_BUF_MAX_LEN);
752 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
754 if(encRetVal.encoded == ENCODE_FAIL)
756 DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
757 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
762 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
763 #ifdef DEBUG_ASN_PRINT
764 for(int i=0; i< encBufSize; i++)
766 printf("%x",encBuf[i]);
771 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
773 DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
779 FreeErrorIndication(e2apMsg);
783 /******************************************************************
785 * @brief Deallocation of memory allocated by aper decoder for e2
786 * Config Update Failure
790 * Function : freeAperDecodingOfE2Node Config UpdateFailure
792 * Functionality: Deallocation of memory allocated by aper decoder
793 * for e2 Config Update Failure
795 * @params[in] E2nodeConfigurationUpdateFailure_t to be deallocated
798 * ****************************************************************/
800 void freeAperDecodingOfE2NodeConfigUpdateFailure(E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail)
806 if(e2NodeCfgUpdFail->protocolIEs.list.array)
808 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
810 if(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx])
812 free(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]);
815 free(e2NodeCfgUpdFail->protocolIEs.list.array);
820 /******************************************************************
822 * @brief Processes E2 Node Config Update Failure sent by RIC
826 * Function : procE2NodeConfigUpdateFailure
828 * Functionality: Processes E2 Node Config Update failure sent by RIC
830 * @params[in] E2AP_PDU_t ASN decoded E2AP message
831 * @return ROK - success
834 * ****************************************************************/
836 void procE2NodeConfigUpdateFailure(E2AP_PDU_t *e2apMsg)
838 uint8_t arrIdx =0, timerValue=0;
840 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
842 DU_LOG("\nINFO --> E2AP : E2 Node Config Update failure received");
843 e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
845 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
847 switch(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->id)
849 case ProtocolIE_IDE2_id_TransactionID:
851 transId = e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
852 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
853 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
855 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
859 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
863 case ProtocolIE_IDE2_id_TimeToWaitE2:
865 timerValue = convertE2WaitTimerEnumToValue(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
866 if((duChkTmr((PTR)&(duCb.e2apDb), EVENT_E2_NODE_CONFIG_UPDATE_TMR)) == FALSE)
868 duStartTmr((PTR)&(duCb.e2apDb), EVENT_E2_NODE_CONFIG_UPDATE_TMR, timerValue);
872 DU_LOG("\nERROR --> E2AP : EVENT_E2_NODE_CONFIG_UPDATE_TMR timer is already running");
879 freeAperDecodingOfE2NodeConfigUpdateFailure(e2NodeCfgUpdFail);
882 /*******************************************************************
884 * @brief Builds Global gNodeB Params
888 * Function : BuildGlobalgNBId
890 * Functionality: Building the Plmn and gNB id
892 * @params[in] GlobalE2node_gNB_ID_t *gNbId
893 * @return ROK - success
896 ******************************************************************/
898 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
901 uint8_t byteSize = 4;
902 uint8_t gnbId = duCb.gnbId;
905 /* fill Global gNB ID Id */
906 gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
907 gNbId->global_gNB_ID.plmn_id.buf = NULLP;
908 DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
909 if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
911 DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
916 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
917 gNbId->global_gNB_ID.plmn_id.buf);
918 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
919 /* Allocate Buffer size */
920 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
921 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
922 DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
923 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
924 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
926 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
931 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId);
936 DU_ALLOC( gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
937 if(gNbId->gNB_DU_ID == NULLP)
939 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID ");
944 gNbId->gNB_DU_ID->size = sizeof(uint8_t);
945 DU_ALLOC( gNbId->gNB_DU_ID->buf, sizeof(uint8_t));
946 if(gNbId->gNB_DU_ID->buf)
948 gNbId->gNB_DU_ID->buf[0] =duCb.e2apDb.e2NodeId;
952 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID buffer");
960 /*******************************************************************
962 * @brief fill the E2 node config information
966 * Function : fillE2NodeConfig
968 * Functionality: fill E2 node config information
971 * Pointer to e2NodeCfg to be filled
972 * E2 Node Component information
973 * Type of configuration
974 * @return ROK - success
977 ******************************************************************/
979 uint8_t fillE2NodeConfig(PTR e2NodeCfg, E2NodeComponent *e2NodeComponentInfo, ConfigType configType)
981 E2NodeConfig *e2NodeConfig=NULLP;
982 E2nodeComponentInterfaceType_t *interfaceType=NULLP;
983 E2nodeComponentID_t *componentID =NULLP;
984 E2nodeComponentConfiguration_t *configuration=NULLP;
985 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
986 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULL;
987 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
993 e2NodeAddItem = (E2nodeComponentConfigAddition_Item_t*)e2NodeCfg;
994 interfaceType = &e2NodeAddItem->e2nodeComponentInterfaceType;
995 componentID = &e2NodeAddItem->e2nodeComponentID;
996 configuration = &e2NodeAddItem->e2nodeComponentConfiguration;
997 e2NodeConfig = e2NodeComponentInfo->addConfiguration;
1002 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_Item_t *) e2NodeCfg;
1003 interfaceType = &e2NodeUpdateItem->e2nodeComponentInterfaceType;
1004 componentID = &e2NodeUpdateItem->e2nodeComponentID;
1005 configuration = &e2NodeUpdateItem->e2nodeComponentConfiguration;
1006 e2NodeConfig = e2NodeComponentInfo->updateConfiguration;
1011 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_Item_t*) e2NodeCfg;
1012 interfaceType = &e2NodeRemovalItem->e2nodeComponentInterfaceType;
1013 componentID = &e2NodeRemovalItem->e2nodeComponentID;
1018 DU_LOG("\nERROR --> E2AP : Configuration type %d does not supported ", configType);
1022 /* E2nodeComponentInterfaceType */
1023 *interfaceType = convertInterfaceToE2ComponentInterfaceType(e2NodeComponentInfo->interfaceType);
1025 /* We now only support the F1 interface out of these interfaces
1026 * (NG,XN,E1,F1,W1,S1,X2), therefore only the F1 component identifier was filled in. */
1028 if(*interfaceType == F1)
1030 /* E2 Node Component ID */
1031 componentID->present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
1032 DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1,sizeof(E2nodeComponentInterfaceF1_t));
1033 if(componentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
1035 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1038 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
1039 DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
1040 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1042 if(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
1044 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1047 memcpy(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, &e2NodeComponentInfo->componentId,\
1048 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1051 if(configType == CONFIG_DEL)
1053 /* We don't need to fill out the E2 Node Component Request and Response
1054 * information in the case of CONFIG_DEL, therefore returning ROK from here. */
1058 /* E2 Node Component Request Part */
1059 if(e2NodeConfig->componentRequestPart)
1061 configuration->e2nodeComponentRequestPart.size = e2NodeConfig->reqBufSize ;
1062 DU_ALLOC(configuration->e2nodeComponentRequestPart.buf,\
1063 configuration->e2nodeComponentRequestPart.size);
1064 if(configuration->e2nodeComponentRequestPart.buf == NULLP)
1066 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1070 memcpy(configuration->e2nodeComponentRequestPart.buf,\
1071 e2NodeConfig->componentRequestPart, configuration->\
1072 e2nodeComponentRequestPart.size);
1076 DU_LOG("\nERROR --> E2AP: componentRequestPart is null ");
1080 /* E2 Node Component Response Part */
1081 if(e2NodeConfig->componentResponsePart)
1083 configuration->e2nodeComponentResponsePart.size = e2NodeConfig->rspBufSize;
1084 DU_ALLOC(configuration->e2nodeComponentResponsePart.buf, configuration->e2nodeComponentResponsePart.size);
1085 if(configuration->e2nodeComponentResponsePart.buf == NULLP)
1087 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1090 memcpy(configuration->e2nodeComponentResponsePart.buf, e2NodeConfig->componentResponsePart, configuration->\
1091 e2nodeComponentResponsePart.size);
1095 DU_LOG("\nERROR --> E2AP: componentResponsePart is null");
1102 /*******************************************************************
1104 * @brief Builds E2 node config addition list
1108 * Function : BuildE2NodeConfigAddList
1110 * Functionality: Building E2 node config addition list
1113 * E2nodeComponentConfigAddition_List_t to be filled
1115 * Count of E2 node to be added in the list
1116 * Received list of E2 node configuration
1118 * @return ROK - success
1121 ******************************************************************/
1123 uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAddList, uint8_t procedureCode, uint16_t count, E2NodeConfigItem *e2NodeList)
1126 CmLList *node =NULL;
1127 E2NodeComponent *e2NodeComponentInfo=NULL;
1128 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe=NULL;
1129 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
1132 /* For ProcedureCodeE2_id_E2setup, the number of E2 node configuration list items is
1133 * equal to the number of E2 node configuration entries stored in the database.
1134 * For any other procedure, the E2 node configuration list count is equal
1135 * to the count of E2 node configuration obtained from the function's caller */
1137 if(procedureCode == ProcedureCodeE2_id_E2setup)
1138 e2NodeAddList->list.count = duCb.e2apDb.e2NodeComponentList.count;
1140 e2NodeAddList->list.count = count;
1142 e2NodeAddList->list.size = e2NodeAddList->list.count * sizeof(E2nodeComponentConfigAddition_ItemIEs_t *);
1143 DU_ALLOC(e2NodeAddList->list.array, e2NodeAddList->list.size);
1144 if(e2NodeAddList->list.array == NULLP)
1146 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
1150 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
1152 DU_ALLOC(e2NodeAddList->list.array[arrIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
1153 if(e2NodeAddList->list.array[arrIdx] == NULLP)
1155 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
1159 if(procedureCode == ProcedureCodeE2_id_E2setup)
1161 /* Getting all of the E2 node configuration's information from DuCb one by one*/
1164 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
1172 DU_LOG("\nERROR --> E2AP : E2 node component list node is null");
1175 e2NodeComponentInfo = (E2NodeComponent*)node->node;
1179 /* Getting only those E2 node configuration from DuCb whose interface
1180 * and action type is present in the received array */
1181 e2NodeComponentInfo = fetchE2NodeComponentInfo(e2NodeList[arrIdx].interface, e2NodeList[arrIdx].componentId, &node);
1184 if(!e2NodeComponentInfo)
1186 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1190 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
1191 e2NodeAddItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition_Item;
1192 e2NodeAddItemIe->criticality = CriticalityE2_reject;
1193 e2NodeAddItemIe->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
1194 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
1195 if(fillE2NodeConfig((PTR)e2NodeAddItem, e2NodeComponentInfo, CONFIG_ADD) != ROK)
1197 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1204 /*******************************************************************
1206 * @brief Builds E2 node config update list
1210 * Function : BuildE2NodeConfigUpdateList
1212 * Functionality: Building E2 node config update list
1215 * E2nodeComponentConfigUpdate_List_t to be filled
1216 * Count of E2 node to be update in the list
1217 * Received list of E2 node configuration
1219 * @return ROK - success
1222 ******************************************************************/
1224 uint8_t BuildE2NodeConfigUpdateList(E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList, uint16_t count, E2NodeConfigItem *updateE2Node)
1227 CmLList *node =NULL;
1228 E2NodeComponent *e2NodeComponentInfo =NULL;
1229 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe =NULL;
1230 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULL;
1232 e2NodeUpdateList->list.count = count;
1233 e2NodeUpdateList->list.size = e2NodeUpdateList->list.count * sizeof(E2nodeComponentConfigUpdate_ItemIEs_t *);
1234 DU_ALLOC(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
1235 if(e2NodeUpdateList->list.array == NULLP)
1237 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
1241 for(arrIdx = 0; arrIdx< e2NodeUpdateList->list.count; arrIdx++)
1243 DU_ALLOC(e2NodeUpdateList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
1244 if(e2NodeUpdateList->list.array[arrIdx] == NULLP)
1246 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
1250 e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface, updateE2Node[arrIdx].componentId, &node);
1251 if(!e2NodeComponentInfo)
1253 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1257 e2NodeUpdateItemIe = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[arrIdx];
1258 e2NodeUpdateItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate_Item;
1259 e2NodeUpdateItemIe->criticality = CriticalityE2_reject;
1260 e2NodeUpdateItemIe->value.present = E2nodeComponentConfigUpdate_ItemIEs__value_PR_E2nodeComponentConfigUpdate_Item;
1261 e2NodeUpdateItem = &e2NodeUpdateItemIe->value.choice.E2nodeComponentConfigUpdate_Item;
1263 if(fillE2NodeConfig((PTR)e2NodeUpdateItem, e2NodeComponentInfo, CONFIG_MOD) != ROK)
1265 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1275 /*******************************************************************
1277 * @brief Builds E2 node config remove list
1281 * Function :BuildE2NodeConfigRemoveList
1283 * Functionality: Building E2 node config remove list
1286 * E2nodeComponentConfigRemoval_List_t to be filled
1287 * Count of E2 node to be remove in the list
1288 * Received list of E2 node configuration
1289 * @return ROK - success
1292 ******************************************************************/
1294 uint8_t BuildE2NodeConfigRemoveList(E2nodeComponentConfigRemoval_List_t *e2NodeRemoveList, uint16_t count, E2NodeConfigItem *updateE2Node)
1298 E2NodeComponent *e2NodeComponentInfo=NULL;
1299 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItemIe=NULL;
1300 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
1302 e2NodeRemoveList->list.count = count;
1303 e2NodeRemoveList->list.size = e2NodeRemoveList->list.count * sizeof(E2nodeComponentConfigRemoval_ItemIEs_t *);
1304 DU_ALLOC(e2NodeRemoveList->list.array, e2NodeRemoveList->list.size);
1305 if(e2NodeRemoveList->list.array == NULLP)
1307 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
1311 for(arrIdx = 0; arrIdx< e2NodeRemoveList->list.count; arrIdx++)
1313 DU_ALLOC(e2NodeRemoveList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
1314 if(e2NodeRemoveList->list.array[arrIdx] == NULLP)
1316 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
1320 e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface,updateE2Node[arrIdx].componentId, &node);
1321 if(!e2NodeComponentInfo)
1323 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1327 e2NodeRemovalItemIe = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemoveList->list.array[arrIdx];
1328 e2NodeRemovalItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval_Item;
1329 e2NodeRemovalItemIe->criticality = CriticalityE2_reject;
1330 e2NodeRemovalItemIe->value.present = E2nodeComponentConfigRemoval_ItemIEs__value_PR_E2nodeComponentConfigRemoval_Item;
1331 e2NodeRemovalItem = &e2NodeRemovalItemIe->value.choice.E2nodeComponentConfigRemoval_Item;
1333 if(fillE2NodeConfig((PTR)e2NodeRemovalItem, e2NodeComponentInfo, CONFIG_DEL) != ROK)
1335 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1342 /*******************************************************************
1344 * @brief deallocation of E2SM_KPM_RANfunction_Description_t
1348 * Function : freeE2smKpmRanFunctionDefinition
1350 * Functionality: deallocation of E2SM_KPM_RANfunction_Description_t
1352 * @params[in] E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition
1355 ******************************************************************/
1357 void freeE2smKpmRanFunctionDefinition(E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition)
1359 MeasurementInfo_Action_Item_t *measInfoList;
1360 uint8_t eventTriggerIdx, reportStyleIdx, measInfoIdx;
1361 RANfunction_Name_t *ranFuncName;
1362 struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle;
1363 struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *eventTriggerStyle;
1364 if(ranFunctionDefinition)
1366 ranFuncName = &ranFunctionDefinition->ranFunction_Name;
1367 /* Free RAN function Name */
1368 DU_FREE(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
1369 DU_FREE(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
1370 DU_FREE(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
1372 /* Sequence of Event Trigger styles */
1373 eventTriggerStyle = ranFunctionDefinition->ric_EventTriggerStyle_List;
1374 if(eventTriggerStyle)
1376 if(eventTriggerStyle->list.array)
1378 for(eventTriggerIdx =0;eventTriggerIdx<eventTriggerStyle->list.count; eventTriggerIdx++)
1380 if(eventTriggerStyle->list.array[eventTriggerIdx])
1382 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.buf,\
1383 eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.size);
1384 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
1387 DU_FREE(eventTriggerStyle->list.array, eventTriggerStyle->list.size)
1389 DU_FREE(eventTriggerStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
1392 /* Sequence of Report styles */
1393 ricReportStyle = ranFunctionDefinition->ric_ReportStyle_List;
1396 if(ricReportStyle->list.array)
1398 for(reportStyleIdx =0;reportStyleIdx<ricReportStyle->list.count; reportStyleIdx++)
1400 if(ricReportStyle->list.array[reportStyleIdx])
1402 if(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf)
1404 DU_FREE(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf,\
1405 ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.size);
1407 if(ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array)
1409 for(measInfoIdx=0; measInfoIdx<ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.count; \
1412 measInfoList = ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array[measInfoIdx];
1415 DU_FREE(measInfoList->measID, sizeof(long));
1416 DU_FREE(measInfoList->measName.buf, measInfoList->measName.size);
1417 DU_FREE(measInfoList,sizeof(MeasurementInfo_Action_Item_t));
1420 DU_FREE(measInfoList,ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.size);
1422 DU_FREE(ricReportStyle->list.array[reportStyleIdx], sizeof(RIC_ReportStyle_Item_t));
1425 DU_FREE(ricReportStyle->list.array, ricReportStyle->list.size);
1427 DU_FREE(ricReportStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1429 DU_FREE(ranFunctionDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1433 /*******************************************************************
1435 * @brief fill the e2sm ric report style
1439 * Function : fillRicReportStyle
1441 * Functionality: fill the report style
1443 * @params[in] RanFunction *ranFuncDb, struct
1444 * E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle
1445 * @return ROK - success
1448 ******************************************************************/
1449 uint8_t fillRicReportStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle)
1451 uint8_t styleIdx, measInfoIdx;
1452 MeasurementInfo_Action_List_t *measInfo;
1455 ricReportStyle->list.count = ranFuncDb->numOfReportStyleSupported;
1456 ricReportStyle->list.size = ricReportStyle->list.count * sizeof(RIC_ReportStyle_Item_t*);
1457 DU_ALLOC(ricReportStyle->list.array, ricReportStyle->list.size);
1458 if(!ricReportStyle->list.array)
1460 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__);
1464 for(styleIdx =0;styleIdx<ricReportStyle->list.count; styleIdx++)
1466 DU_ALLOC(ricReportStyle->list.array[styleIdx], sizeof(RIC_ReportStyle_Item_t));
1467 if(!ricReportStyle->list.array[styleIdx])
1469 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1473 /* RIC Report Style Type */
1474 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType;
1476 /* RIC Report Style Format Type */
1477 ricReportStyle->list.array[styleIdx]->ric_ActionFormat_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType;
1479 /* RIC Report Style Name */
1480 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size = strlen(ranFuncDb->reportStyleList[styleIdx].reportStyle.name);
1481 DU_ALLOC(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf,\
1482 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1483 if(!ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf)
1485 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1488 memcpy(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf, ranFuncDb->reportStyleList[styleIdx].reportStyle.name,\
1489 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1491 /* RIC Indication Header Format Type*/
1492 ricReportStyle->list.array[styleIdx]->ric_IndicationHeaderFormat_Type = ranFuncDb->ricIndicationHeaderFormat;
1494 /* RIC Indication Message Format Type*/
1495 ricReportStyle->list.array[styleIdx]->ric_IndicationMessageFormat_Type = ranFuncDb->ricIndicationMessageFormat;
1497 /* Measurement Info Action List */
1498 CmLListCp measInfoList =ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
1499 if(!measInfoList.count)
1504 CM_LLIST_FIRST_NODE(&ranFuncDb->reportStyleList[styleIdx].measurementInfoList, node);
1505 measInfo = &ricReportStyle->list.array[styleIdx]->measInfo_Action_List;
1507 measInfo->list.count = measInfoList.count;
1508 measInfo->list.size = measInfoList.count*sizeof(MeasurementInfo_Action_Item_t*);
1509 DU_ALLOC(measInfo->list.array, measInfo->list.size);
1510 if(!measInfo->list.array)
1512 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1516 for(measInfoIdx=0; measInfoIdx<measInfo->list.count; measInfoIdx++)
1520 DU_LOG("\nERROR --> E2AP: Measurement info node is null");
1524 DU_ALLOC(measInfo->list.array[measInfoIdx],sizeof(MeasurementInfo_Action_Item_t));
1525 if(!measInfo->list.array[measInfoIdx])
1527 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1530 MeasurementInfoForAction *measInfoForAction= (MeasurementInfoForAction*)node->node;
1531 DU_ALLOC(measInfo->list.array[measInfoIdx]->measID, sizeof(long));
1532 if(!measInfo->list.array[measInfoIdx]->measID)
1534 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1538 memcpy(measInfo->list.array[measInfoIdx]->measID, &measInfoForAction->measurementTypeId,sizeof(long));
1539 measInfo->list.array[measInfoIdx]->measName.size= strlen(measInfoForAction->measurementTypeName);
1540 DU_ALLOC(measInfo->list.array[measInfoIdx]->measName.buf, measInfo->list.array[measInfoIdx]->measName.size);
1541 if(!measInfo->list.array[measInfoIdx]->measName.size)
1543 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1547 memcpy(measInfo->list.array[measInfoIdx]->measName.buf, \
1548 measInfoForAction->measurementTypeName,\
1549 measInfo->list.array[measInfoIdx]->measName.size);
1556 /*******************************************************************
1558 * @brief fill the ric event trigger style
1562 * Function : fillRicEventTriggerStyle
1564 * Functionality: fill the ric event trigger style
1567 * @return ROK - success
1570 ******************************************************************/
1571 uint8_t fillRicEventTriggerStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *ricEventTriggerStyle)
1575 ricEventTriggerStyle->list.count = ranFuncDb->numOfEventTriggerStyleSupported;
1576 ricEventTriggerStyle->list.size = ricEventTriggerStyle->list.count* sizeof(RIC_EventTriggerStyle_Item_t *);
1577 DU_ALLOC(ricEventTriggerStyle->list.array, ricEventTriggerStyle->list.size);
1578 if(!ricEventTriggerStyle->list.array)
1580 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__);
1584 for(styleIdx =0;styleIdx<ricEventTriggerStyle->list.count; styleIdx++)
1586 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
1587 if(!ricEventTriggerStyle->list.array[styleIdx])
1589 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1592 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Type = ranFuncDb->eventTriggerStyleList[styleIdx].styleType;
1594 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerFormat_Type = ranFuncDb->eventTriggerStyleList[styleIdx].formatType;
1596 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size = strlen(ranFuncDb->eventTriggerStyleList[styleIdx].name);
1597 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,\
1598 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1599 if(!ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf)
1601 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1604 memcpy(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,ranFuncDb->eventTriggerStyleList[styleIdx].name,\
1605 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1611 /*******************************************************************
1613 * @brief Builds Ran function item
1617 * Function : BuildRanFunctionItem
1619 * Functionality: Building RAN function item
1622 * RAN function item that has to be filled
1623 * Stored RAN Function information
1624 * @return ROK - success
1627 ******************************************************************/
1629 uint8_t BuildRanFunctionItem(RANfunction_Item_t *ranFuncItem, RanFunction *ranFuncDb)
1631 uint8_t ret =RFAILED;
1632 RANfunctionDefinition_t *ranFunctionDefinition;
1633 RANfunction_Name_t *ranFuncName;
1634 asn_enc_rval_t encRetVal;
1635 E2SM_KPM_RANfunction_Description_t *ranFuncDefinition;
1639 /* RAN function Id*/
1640 ranFuncItem->ranFunctionID = ranFuncDb->id;
1642 /* RAN Function Revision*/
1643 ranFuncItem->ranFunctionRevision = ranFuncDb->revisionCounter;
1645 /* RAN function OID*/
1646 ranFuncItem->ranFunctionOID.size = strlen(ranFuncDb->name.serviceModelOID);
1647 DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size);
1648 if(!ranFuncItem->ranFunctionOID.buf)
1650 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1653 memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size);
1655 /* RAN function Definition */
1656 DU_ALLOC(ranFuncDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1657 if(!ranFuncDefinition)
1659 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1663 /* RAN function Name */
1664 ranFuncName = &ranFuncDefinition->ranFunction_Name;
1666 /* RAN function ShortName */
1667 ranFuncName->ranFunction_ShortName.size = strlen(ranFuncDb->name.shortName);
1668 DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
1669 if(!ranFuncName->ranFunction_ShortName.buf)
1671 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1674 memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName));
1676 /* RAN function E2SM_OID */
1677 ranFuncName->ranFunction_E2SM_OID.size = strlen(ranFuncDb->name.serviceModelOID);
1678 DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
1679 if(!ranFuncName->ranFunction_E2SM_OID.buf)
1681 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1684 memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
1686 /* RAN Function Name Description */
1687 ranFuncName->ranFunction_Description.size = strlen(ranFuncDb->name.description);
1688 DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
1689 if(!ranFuncName->ranFunction_Description.buf)
1691 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1694 memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size);
1696 /* RIC Event Trigger Style List */
1697 DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
1698 if(!ranFuncDefinition->ric_EventTriggerStyle_List)
1700 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1704 if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
1706 DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
1710 /* RIC Report Style List */
1711 DU_ALLOC(ranFuncDefinition->ric_ReportStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1712 if(!ranFuncDefinition->ric_ReportStyle_List)
1714 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1717 if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
1719 DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
1723 /* Encode the F1SetupRequest type as APER */
1724 xer_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, ranFuncDefinition);
1726 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1728 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_RANfunction_Description, 0, ranFuncDefinition, PrepFinalEncBuf, encBuf);
1730 /* Encode results */
1731 if(encRetVal.encoded == ENCODE_FAIL)
1733 DU_LOG("\nERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\
1734 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1739 DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n");
1740 for(uint8_t measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
1742 printf("%x",encBuf[measIeIdx]);
1744 ranFunctionDefinition = &ranFuncItem->ranFunctionDefinition;
1745 ranFunctionDefinition->size = encBufSize;
1746 DU_ALLOC(ranFunctionDefinition->buf, encBufSize);
1747 if(ranFunctionDefinition->buf == NULLP)
1749 DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
1752 memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize);
1757 freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
1761 /*******************************************************************
1763 * @brief Builds Ran function add list based on the procedure code
1767 * Function : BuildRanFunctionAddList
1769 * Functionality: Building RAN addition addition list
1770 * In case of ProcedureCodeE2_id_E2setup we add all the RAN Function list
1771 * which is present in E2 database.
1772 * In the case of other procedures, we just fill the RAN functions whose ID
1773 * is contained in recvList
1778 * Count of ran functions to be added in the list
1779 * Received list of RAN functions
1781 * @return ROK - success
1784 ******************************************************************/
1786 uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList, uint8_t procedureCode, uint8_t count, RanFuncInfo *recvList)
1789 RanFunction *ranFuncDb;
1791 RANfunction_ItemIEs_t *ranFuncItemIe;
1793 /* For ProcedureCodeE2_id_E2setup, the number of RAN function list items is
1794 * equal to the number of ran function entries stored in the database.
1795 * For any other procedure, the RAN function list count is equal
1796 * to the count of ran functions obtained from the function's caller */
1798 if(procedureCode == ProcedureCodeE2_id_E2setup)
1799 ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
1801 ranFunctionsList->list.count = count;
1803 ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*);
1804 DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
1805 if(ranFunctionsList->list.array == NULLP)
1807 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1811 for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++)
1813 DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1814 if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
1816 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1819 if(procedureCode == ProcedureCodeE2_id_E2setup)
1821 /* Getting all of the RAN function's information from DuCb one by one*/
1822 ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
1826 /* Getting only the RAN function information from DuCb whose Id is
1827 * present in the received array */
1828 id =recvList[ranFuncIdx].id;
1829 ranFuncDb = &duCb.e2apDb.ranFunction[id-1];
1831 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1832 ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item;
1833 ranFuncItemIe->criticality = CriticalityE2_ignore;
1834 ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
1835 BuildRanFunctionItem(&ranFuncItemIe->value.choice.RANfunction_Item, ranFuncDb);
1840 /*******************************************************************
1842 * @brief De Allocate E2 Setup Request Message
1846 * Function : FreeE2SetupReq
1848 * Functionality: De-Allocating E2 Setup request Message
1850 * @params[in] E2AP_PDU_t *e2apMsg
1854 * ****************************************************************/
1856 void FreeE2SetupReq(E2AP_PDU_t *e2apMsg)
1859 uint8_t e2NodeAddListIdx =0, ranFuncAddListIdx;
1860 E2setupRequest_t *e2SetupReq;
1861 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1862 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1863 RANfunctions_List_t *ranFunctionsList;
1864 RANfunction_ItemIEs_t *ranFuncItemIe;
1865 RANfunction_Item_t *ranFunItem;
1867 /* De-allocating Memory */
1868 if(e2apMsg != NULLP)
1870 if(e2apMsg->choice.initiatingMessage != NULLP)
1872 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
1873 if(e2SetupReq->protocolIEs.list.array != NULLP)
1875 for(arrIdx = 0; arrIdx < e2SetupReq->protocolIEs.list.count; arrIdx++)
1877 if(e2SetupReq->protocolIEs.list.array[arrIdx] != NULLP)
1879 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1881 case ProtocolIE_IDE2_id_TransactionID:
1883 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1885 if(e2SetupReq->protocolIEs.list.array[arrIdx]->\
1886 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
1888 GlobalE2node_gNB_ID_t *gNbId = NULLP;
1889 gNbId = e2SetupReq->protocolIEs.list.array[arrIdx]->\
1890 value.choice.GlobalE2node_ID.choice.gNB;
1891 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
1893 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
1894 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
1895 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
1896 gNbId->global_gNB_ID.plmn_id.size);
1899 if(gNbId->gNB_DU_ID != NULLP)
1901 DU_FREE( gNbId->gNB_DU_ID->buf, gNbId->gNB_DU_ID->size);
1902 DU_FREE(gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
1904 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
1905 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
1909 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1911 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1912 if(e2NodeAddList->list.array)
1914 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1916 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
1918 /* Free E2 Node Component Request Part */
1919 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
1920 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
1922 /* Free E2 Node Component Response Part */
1923 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.\
1924 e2nodeComponentResponsePart.buf, \
1925 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
1927 /* Free E2 Node Component ID */
1928 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1)
1930 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1931 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
1932 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1933 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1934 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
1935 sizeof(E2nodeComponentInterfaceF1_t));
1937 DU_FREE(e2NodeAddList->list.array[e2NodeAddListIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
1939 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
1943 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1945 ranFunctionsList = &(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
1946 if(ranFunctionsList->list.array)
1948 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
1950 if(ranFunctionsList->list.array[ranFuncAddListIdx])
1952 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
1953 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1954 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
1955 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
1956 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
1959 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
1965 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
1966 (e2SetupReq->protocolIEs.list.array[arrIdx]->id));
1969 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx], sizeof(E2setupRequestIEs_t));
1972 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
1974 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1976 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1980 /*******************************************************************
1982 * @brief Builds and Send the E2SetupRequest
1986 * Function : BuildAndSendE2SetupReq
1988 * Functionality:Fills the E2SetupRequest
1990 * @return ROK - success
1993 ******************************************************************/
1995 uint8_t BuildAndSendE2SetupReq()
1997 uint16_t transId = 0;
1998 uint8_t arrIdx = 0, elementCnt=0, ret =RFAILED;
1999 bool memAllocFailed = false;
2000 E2AP_PDU_t *e2apMsg = NULLP;
2001 E2setupRequest_t *e2SetupReq = NULLP;
2002 asn_enc_rval_t encRetVal; /* Encoder return value */
2004 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
2007 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2008 if(e2apMsg == NULLP)
2010 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2013 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2014 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2015 if(e2apMsg->choice.initiatingMessage == NULLP)
2017 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2020 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2021 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
2022 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
2023 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
2026 e2SetupReq->protocolIEs.list.count = elementCnt;
2027 e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*);
2029 /* Initialize the E2Setup members */
2030 DU_ALLOC(e2SetupReq->protocolIEs.list.array, \
2031 e2SetupReq->protocolIEs.list.size);
2032 if(e2SetupReq->protocolIEs.list.array == NULLP)
2034 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
2037 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
2039 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx],\
2040 sizeof(E2setupRequestIEs_t));
2041 if(e2SetupReq->protocolIEs.list.array[arrIdx] == NULLP)
2043 memAllocFailed = true;
2044 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
2048 if(memAllocFailed == true)
2054 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2055 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2056 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
2057 transId = assignTransactionId();
2058 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2061 /* GlobalE2node_gNB_ID */
2062 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
2063 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2064 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
2065 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
2067 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
2068 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
2069 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
2070 GlobalE2node_ID.choice.gNB == NULLP)
2072 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
2077 ret = BuildGlobalgNBId(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
2078 choice.GlobalE2node_ID.choice.gNB);
2081 DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
2086 /* RAN Functions Added List */
2088 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
2089 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2090 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
2091 if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
2093 DU_LOG("\nERROR --> E2AP : Failed to create RAN Function");
2097 /* E2 Node Component Configuration Addition List */
2099 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
2100 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2101 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
2102 if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
2104 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
2110 /* Prints the Msg formed */
2111 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2113 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2115 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
2117 if(encRetVal.encoded == ENCODE_FAIL)
2119 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
2120 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2125 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
2126 #ifdef DEBUG_ASN_PRINT
2127 for(int i=0; i< encBufSize; i++)
2129 printf("%x",encBuf[i]);
2133 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2135 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
2140 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
2141 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
2143 FreeE2SetupReq(e2apMsg);
2145 }/* End of BuildAndSendE2SetupReq */
2147 /*******************************************************************
2149 * @brief Builds RIC Action Admitted List
2153 * Function : BuildRicActionAdmitList
2155 * Functionality: Builds RIC Action Admitted List
2157 * @params[in] Pointer to RIC Action Admitted List to be filled
2158 * Subscription Response information
2159 * @return ROK - success
2162 * ****************************************************************/
2163 uint8_t BuildRicActionAdmitList(RICaction_Admitted_List_t *admitList, PendingSubsRspInfo *subsRspInfo)
2166 uint8_t elementCnt = 0;
2167 RICaction_Admitted_ItemIEs_t *admitItem = NULLP;
2169 elementCnt = subsRspInfo->numOfAcceptedActions;
2171 admitList->list.count = elementCnt;
2172 admitList->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t *);
2174 DU_ALLOC(admitList->list.array, admitList->list.size);
2175 if(admitList->list.array == NULLP)
2177 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2181 for(idx=0; idx<elementCnt; idx++)
2183 DU_ALLOC(admitList->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
2184 if(admitList->list.array[idx] == NULLP)
2186 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2190 admitItem = (RICaction_Admitted_ItemIEs_t *)admitList->list.array[idx];
2191 admitItem->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
2192 admitItem->criticality = CriticalityE2_reject;
2193 admitItem->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
2194 admitItem->value.choice.RICaction_Admitted_Item.ricActionID = subsRspInfo->acceptedActionList[idx];
2199 /*******************************************************************
2201 * @brief Builds RIC Action Not Admitted List
2205 * Function : BuildRicActionNotAdmitList
2207 * Functionality: Builds RIC Action Not Admitted List
2209 * @params[in] Pointer to RIC Action Not Admitted List to be filled
2210 * Subscription Response information
2211 * @return ROK - success
2214 * ****************************************************************/
2215 uint8_t BuildRicActionNotAdmitList(RICaction_NotAdmitted_List_t *notAdmitList, PendingSubsRspInfo *subsRspInfo)
2218 uint8_t elementCnt = 0;
2219 RICaction_NotAdmitted_ItemIEs_t *notAdmitItem = NULLP;
2221 elementCnt = subsRspInfo->numOfRejectedActions;
2223 notAdmitList->list.count = elementCnt;
2224 notAdmitList->list.size = elementCnt * sizeof(RICaction_NotAdmitted_ItemIEs_t *);
2226 DU_ALLOC(notAdmitList->list.array, notAdmitList->list.size);
2227 if(notAdmitList->list.array == NULLP)
2229 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2233 for(idx=0; idx<elementCnt; idx++)
2235 DU_ALLOC(notAdmitList->list.array[idx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
2236 if(notAdmitList->list.array[idx] == NULLP)
2238 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2242 notAdmitItem = (RICaction_NotAdmitted_ItemIEs_t *)notAdmitList->list.array[idx];
2243 notAdmitItem->id = ProtocolIE_IDE2_id_RICaction_NotAdmitted_Item;
2244 notAdmitItem->criticality = CriticalityE2_reject;
2245 notAdmitItem->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;
2246 notAdmitItem->value.choice.RICaction_NotAdmitted_Item.ricActionID = \
2247 subsRspInfo->rejectedActionList[idx].id;
2248 fillE2Cause(¬AdmitItem->value.choice.RICaction_NotAdmitted_Item.cause, \
2249 subsRspInfo->rejectedActionList[idx].failureCause);
2254 /*******************************************************************
2256 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
2260 * Function : FreeRicSubscriptionRsp
2262 * Functionality:Free the RicSubscriptionRsp
2264 * @param[in] E2AP_PDU_t *e2apRicMsg
2268 ******************************************************************/
2269 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
2271 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
2274 RICaction_Admitted_List_t *admitList = NULLP;
2275 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
2277 if(e2apRicMsg != NULLP)
2279 if(e2apRicMsg->choice.successfulOutcome != NULLP)
2281 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2282 if(ricSubscriptionRsp)
2284 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
2286 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
2288 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
2290 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
2292 case ProtocolIE_IDE2_id_RICactions_Admitted:
2294 admitList = &ricSubscriptionRsp->protocolIEs.list.\
2295 array[idx]->value.choice.RICaction_Admitted_List;
2296 if(admitList->list.array != NULLP)
2298 for(listIdx=0 ; listIdx < admitList->list.count; listIdx++)
2300 DU_FREE(admitList->list.array[listIdx], sizeof(RICaction_Admitted_ItemIEs_t));
2302 DU_FREE(admitList->list.array, admitList->list.size);
2306 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
2308 notAdmitList = &ricSubscriptionRsp->protocolIEs.list.\
2309 array[idx]->value.choice.RICaction_NotAdmitted_List;
2310 if(notAdmitList->list.array != NULLP)
2312 for(listIdx=0 ; listIdx < notAdmitList->list.count; listIdx++)
2314 DU_FREE(notAdmitList->list.array[listIdx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
2316 DU_FREE(notAdmitList->list.array, notAdmitList->list.size);
2323 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], sizeof(RICsubscriptionResponse_IEs_t));
2326 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
2329 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2331 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
2335 /*******************************************************************
2337 * @brief Fill RIC Subscription Response IEs
2341 * Function : fillRicSubscriptionRsp
2343 * functionality: Fill RIC Subscription Response IEs
2345 * @param Pointer to RIC subscription response
2346 * Subscription response information
2347 * @return ROK - success
2350 ******************************************************************/
2351 uint8_t fillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp, PendingSubsRspInfo *subsRspInfo)
2354 uint8_t elementCnt = 0;
2355 RICsubscriptionResponse_IEs_t *subsRspIe = NULLP;
2358 if(subsRspInfo->numOfRejectedActions)
2361 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
2362 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
2363 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
2364 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
2366 DU_LOG("\nERROR --> E2AP : Memory allocation failed at %s : line %d", __func__, __LINE__);
2370 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
2372 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionResponse_IEs_t));
2373 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx] == NULLP)
2375 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d] : ieIdx [%d]", __func__, __LINE__,ieIdx);
2380 /* RIC Request ID */
2382 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2383 subsRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
2384 subsRspIe->criticality = CriticalityE2_reject;
2385 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
2386 subsRspIe->value.choice.RICrequestID.ricRequestorID = subsRspInfo->requestId.requestorId;
2387 subsRspIe->value.choice.RICrequestID.ricInstanceID = subsRspInfo->requestId.instanceId;
2389 /* RAN Function ID */
2391 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2392 subsRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
2393 subsRspIe->criticality = CriticalityE2_reject;
2394 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
2395 subsRspIe->value.choice.RANfunctionID = subsRspInfo->ranFuncId;
2397 /* RIC Action Admitted List */
2399 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2400 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_Admitted;
2401 subsRspIe->criticality = CriticalityE2_reject;
2402 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
2403 if(BuildRicActionAdmitList(&subsRspIe->value.choice.RICaction_Admitted_List, subsRspInfo) != ROK)
2405 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Admitted List in RIC Subscription Response");
2409 /* RIC Action Not Admitted List */
2410 if(subsRspInfo->numOfRejectedActions)
2413 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2414 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_NotAdmitted;
2415 subsRspIe->criticality = CriticalityE2_reject;
2416 subsRspIe->criticality = CriticalityE2_reject;
2417 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
2418 if(BuildRicActionNotAdmitList(&subsRspIe->value.choice.RICaction_NotAdmitted_List, subsRspInfo) != ROK)
2420 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Not Admitted List in RIC Subscription Response");
2428 /*******************************************************************
2430 * @brief Builds and Send the RicSubscriptionRsp
2434 * Function : BuildAndSendRicSubscriptionRsp
2436 * Functionality:Fills the RicSubscriptionRsp
2438 * @return ROK - success
2441 ******************************************************************/
2443 uint8_t BuildAndSendRicSubscriptionRsp(PendingSubsRspInfo *subsRspInfo)
2445 uint8_t ret = RFAILED;
2446 E2AP_PDU_t *e2apRicMsg = NULLP;
2447 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
2448 asn_enc_rval_t encRetVal;
2452 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
2454 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
2455 if(e2apRicMsg == NULLP)
2457 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2461 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
2462 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2463 if(e2apRicMsg->choice.successfulOutcome == NULLP)
2465 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
2469 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
2470 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2471 e2apRicMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
2473 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2475 if(fillRicSubscriptionRsp(ricSubscriptionRsp, subsRspInfo) != ROK)
2477 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
2481 /* Prints the Msg formed */
2482 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
2484 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2486 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
2487 if(encRetVal.encoded == ENCODE_FAIL)
2489 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
2490 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2495 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
2496 #ifdef DEBUG_ASN_PRINT
2497 for(int i=0; i< encBufSize; i++)
2499 printf("%x",encBuf[i]);
2504 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2506 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
2515 FreeRicSubscriptionRsp(e2apRicMsg);
2519 /******************************************************************
2521 * @brief Deallocation of memory allocated by aper decoder for e2 setup response
2525 * Function : freeAperDecodingOfE2SetupRsp
2527 * Functionality: Deallocation of memory allocated by aper decoder for e2
2530 * @params[in] E2setupResponse_t *e2SetRspMsg;
2533 * ****************************************************************/
2534 void freeAperDecodingOfE2SetupRsp(E2setupResponse_t *e2SetRspMsg)
2536 uint8_t arrIdx, e2NodeConfigAddAckListIdx;
2537 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
2538 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAddAckList;
2542 if(e2SetRspMsg->protocolIEs.list.array)
2544 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2546 if(e2SetRspMsg->protocolIEs.list.array[arrIdx])
2548 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2550 case ProtocolIE_IDE2_id_TransactionID:
2553 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2555 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.pLMN_Identity.buf);
2556 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID.buf);
2560 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2562 e2NodeConfigAddAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2563 if(e2NodeConfigAddAckList->list.array )
2565 for(e2NodeConfigAddAckListIdx = 0; e2NodeConfigAddAckListIdx< e2NodeConfigAddAckList->list.count; e2NodeConfigAddAckListIdx++)
2567 if(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx])
2569 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx];
2570 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2571 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf);
2572 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2573 e2nodeComponentInterfaceTypeF1);
2574 free(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx]);
2577 free(e2NodeConfigAddAckList->list.array);
2582 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]);
2585 free(e2SetRspMsg->protocolIEs.list.array);
2590 /******************************************************************
2592 * @brief handling of e2 noe config update ack ies
2596 * Function :handleE2NodeConfigUpdateAckIes
2598 * Functionality: handling of e2 noe config update ack ies
2601 * Pointer to the E2 Node cfg
2604 ******************************************************************/
2606 void handleE2NodeConfigUpdateAckIes(PTR e2NodeCfg, uint8_t procedureCode)
2608 CmLList *node=NULLP;
2609 E2NodeComponent *e2NodeComponentInfo=NULLP;
2610 E2nodeComponentID_t *e2nodeComponentID=NULLP;
2611 E2nodeComponentConfigRemovalAck_Item_t *removalAckItem=NULLP;
2612 E2nodeComponentConfigUpdateAck_Item_t *updateAckItem=NULLP;
2613 E2nodeComponentConfigAdditionAck_Item_t *additionAckItem=NULLP;
2615 switch(procedureCode)
2617 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2619 additionAckItem = (E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg;
2620 e2nodeComponentID = &additionAckItem->e2nodeComponentID;
2623 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
2625 updateAckItem = (E2nodeComponentConfigUpdateAck_Item_t*) e2NodeCfg;
2626 e2nodeComponentID = &updateAckItem->e2nodeComponentID;
2629 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
2631 removalAckItem= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
2632 e2nodeComponentID = &removalAckItem->e2nodeComponentID;
2637 switch(e2nodeComponentID->present)
2639 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
2641 e2NodeComponentInfo = fetchE2NodeComponentInfo(F1, e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0], &node);
2642 if(!e2NodeComponentInfo)
2644 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
2653 switch(procedureCode)
2655 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2657 DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, e2NodeComponentInfo->addConfiguration->reqBufSize);
2658 DU_FREE(e2NodeComponentInfo->addConfiguration->componentResponsePart, e2NodeComponentInfo->addConfiguration->rspBufSize);
2659 DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
2662 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
2664 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentRequestPart, e2NodeComponentInfo->updateConfiguration->reqBufSize);
2665 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentResponsePart, e2NodeComponentInfo->updateConfiguration->rspBufSize);
2666 DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
2669 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
2671 cmLListDelFrm(&duCb.e2apDb.e2NodeComponentList, node);
2672 if(e2NodeComponentInfo->addConfiguration)
2674 DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, e2NodeComponentInfo->addConfiguration->reqBufSize);
2675 DU_FREE(e2NodeComponentInfo->addConfiguration->componentResponsePart, e2NodeComponentInfo->addConfiguration->rspBufSize);
2676 DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
2678 if(e2NodeComponentInfo->updateConfiguration)
2680 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentRequestPart, e2NodeComponentInfo->updateConfiguration->reqBufSize);
2681 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentResponsePart, e2NodeComponentInfo->updateConfiguration->rspBufSize);
2682 DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
2684 DU_FREE(node, sizeof(CmLList));
2690 /******************************************************************
2692 * @brief Processes E2 Setup Response sent by RIC
2696 * Function : procE2SetupRsp
2698 * Functionality: Processes E2 Setup Response sent by RIC
2700 * @params[in] E2AP_PDU_t ASN decoded E2AP message
2703 * ****************************************************************/
2705 void procE2SetupRsp(E2AP_PDU_t *e2apMsg)
2707 bool invalidTransId = false;
2708 uint8_t arrIdx =0, idx=0;
2710 uint32_t recvBufLen;
2711 E2setupResponse_t *e2SetRspMsg=NULL;
2712 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
2713 RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL;
2714 RANfunctionsIDcause_List_t *ranFuncRejectedList=NULL;
2715 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
2716 E2nodeComponentConfigAdditionAck_List_t *e2NodeCfgAckList=NULL;
2717 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem=NULL;
2719 DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
2720 duCb.e2Status = TRUE; //Set E2 status as true
2721 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
2723 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2725 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2727 case ProtocolIE_IDE2_id_TransactionID:
2729 transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2730 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
2731 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
2733 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
2737 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
2738 invalidTransId = true;
2743 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2745 /* To store the Ric Id Params */
2746 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value\
2747 .choice.GlobalRIC_ID.pLMN_Identity.size);
2748 memcpy(&duCb.e2apDb.ricId.plmnId, e2SetRspMsg->protocolIEs.list.array[arrIdx]\
2749 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
2750 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID, &duCb.e2apDb.ricId);
2751 /*TODO : duCb.e2apDb.ricId.plmnId memory to be deallocated after the usage */
2755 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2757 e2NodeCfgAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2758 for(idx =0; idx <e2NodeCfgAckList->list.count; idx++)
2760 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeCfgAckList->list.array[idx];
2761 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
2762 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
2766 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2768 ranFuncAcceptedList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2769 for(idx =0; idx <ranFuncAcceptedList->list.count; idx++)
2771 ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[idx];
2772 DU_LOG("\nINFO --> E2AP : Ran function id [%ld] accepted",ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID);
2777 case ProtocolIE_IDE2_id_RANfunctionsRejected:
2779 ranFuncRejectedList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
2780 for(idx =0; idx <ranFuncRejectedList->list.count; idx++)
2782 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[idx];
2783 DU_LOG("\nINFO --> E2AP : Ran function id [%ld] rejected",ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID);
2789 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
2790 e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
2795 if(invalidTransId == true)
2800 freeAperDecodingOfE2SetupRsp(e2SetRspMsg);
2802 if(invalidTransId == false)
2804 if(duSendE2NodeConfigurationUpdate() != ROK)
2806 DU_LOG("\nERROR --> E2AP : Failed to send E2 node config update");
2811 /*******************************************************************
2813 * @brief Free RIC Subscription Request
2817 * Function : freeAperDecodingOfRicSubsReq
2819 * Functionality : Free RIC Subscription Request
2823 ******************************************************************/
2824 void freeAperDecodingOfRicSubsReq(RICsubscriptionRequest_t *ricSubscriptionReq)
2827 uint8_t elementIdx = 0;
2828 RICsubscriptionDetails_t *subsDetails = NULLP;
2829 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
2831 if(ricSubscriptionReq->protocolIEs.list.array)
2833 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
2835 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
2837 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
2839 subsDetails = &(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails);
2840 free(subsDetails->ricEventTriggerDefinition.buf);
2842 if(subsDetails->ricAction_ToBeSetup_List.list.array)
2844 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
2846 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
2848 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
2849 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
2851 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf);
2852 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition);
2854 free(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]);
2857 free(subsDetails->ricAction_ToBeSetup_List.list.array);
2862 free(ricSubscriptionReq->protocolIEs.list.array[idx]);
2864 free(ricSubscriptionReq->protocolIEs.list.array);
2868 /*******************************************************************
2870 * @brief Free Event Trigger Definition
2874 * Function : freeAperDecodingOfEventTriggerDef
2876 * Functionality: Free Event Trigger Definition
2878 * @params[in] E2SM-KPM Event Trigger Definition
2881 * ****************************************************************/
2882 void freeAperDecodingOfEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
2886 switch(eventTiggerDef->eventDefinition_formats.present)
2888 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
2891 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
2892 free(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1);
2898 /*******************************************************************
2900 * @brief Extract E2SM-KPM Event trigger definition
2904 * Function : extractEventTriggerDef
2906 * Functionality : This function :
2907 * - Decodes E2SM-KPM Event Trigger Definition
2908 * - Validates that even trigger style is supported by E2 node
2909 * - Stores event trigger details in local DB
2911 * @params[in] RAN Function Database structure
2912 * RIC Subscription Info to be added to RAN function
2913 * RIC Event Trigger Definition buffer received from RIC
2914 * @return ROK - success
2917 ******************************************************************/
2918 uint8_t extractEventTriggerDef(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
2919 RICeventTriggerDefinition_t *ricEventTriggerDef, E2FailureCause *failureCause)
2921 uint8_t ret = RFAILED;
2922 uint8_t eventIdx = 0;
2923 asn_dec_rval_t rval ={0};
2924 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef, *eventTiggerDefPtr = NULLP;
2926 /* Decoding E2SM-KPM Even Trigger Definition */
2927 eventTiggerDefPtr = &eventTiggerDef;
2928 memset(eventTiggerDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
2930 rval = aper_decode(0, &asn_DEF_E2SM_KPM_EventTriggerDefinition, (void **)&eventTiggerDefPtr, ricEventTriggerDef->buf,\
2931 ricEventTriggerDef->size, 0, 0);
2932 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2934 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Event Trigger Definition");
2935 failureCause->causeType = E2_PROTOCOL;
2936 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
2940 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, eventTiggerDefPtr);
2942 /* Validating the received event trigger definition format */
2943 for(eventIdx = 0; eventIdx < ranFuncDb->numOfEventTriggerStyleSupported; eventIdx++)
2945 if((eventTiggerDefPtr->eventDefinition_formats.present != \
2946 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING) && \
2947 (eventTiggerDefPtr->eventDefinition_formats.present == ranFuncDb->eventTriggerStyleList[eventIdx].formatType))
2949 ricSubscriptionInfo->eventTriggerDefinition.formatType = ranFuncDb->eventTriggerStyleList[eventIdx].formatType;
2950 ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod = \
2951 eventTiggerDefPtr->eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod;
2960 failureCause->causeType = E2_RIC_REQUEST;
2961 failureCause->cause = E2_EVENT_TRIGGER_NOT_SUPPORTED;
2963 /* Free E2SM_KPM_EventTriggerDefinition_t */
2964 freeAperDecodingOfEventTriggerDef(eventTiggerDefPtr);
2968 /*******************************************************************
2970 * @brief Free RIC Action Definition
2974 * Function : freeAperDecodingOfRicActionDefinition
2976 * Functionality: Free RIC Action Definition
2978 * @params[in] E2SM-KPM Action definition
2981 * ****************************************************************/
2982 void freeAperDecodingOfRicActionDefinition(E2SM_KPM_ActionDefinition_t *actionDef)
2984 uint8_t elementIdx = 0;
2985 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
2986 MeasurementInfoItem_t *measItem = NULLP;
2988 switch(actionDef->actionDefinition_formats.present)
2990 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
2992 if(actionDef->actionDefinition_formats.choice.actionDefinition_Format1)
2994 actionFormat1 = actionDef->actionDefinition_formats.choice.actionDefinition_Format1;
2995 if(actionFormat1->measInfoList.list.array)
2997 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
2999 if(actionFormat1->measInfoList.list.array[elementIdx])
3001 measItem = actionFormat1->measInfoList.list.array[elementIdx];
3002 switch(measItem->measType.present)
3004 case MeasurementType_PR_NOTHING:
3007 case MeasurementType_PR_measName:
3009 free(measItem->measType.choice.measName.buf);
3013 case MeasurementType_PR_measID:
3019 free(actionFormat1->measInfoList.list.array);
3021 free(actionFormat1);
3025 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
3026 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
3027 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
3028 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
3034 /*******************************************************************
3036 * @brief Extract Measurement Info list from action definition
3040 * Function : extractMeasInfoList
3042 * Functionality : This function :
3043 * - Traverses Measurement-to-be-subscribed list
3044 * - Validates that each measurement in Measurement-to-be-subscribed
3045 * list is supported in RAN-Function->Measurement-supported list.
3046 * - If all measurements in an action is supported by RAN function,
3047 * it is added to measurement-subscribed list in local DB
3049 * @params[in] Measurement Info supported list by RAN function
3050 * Measurement Info to be subscribed as requested by RIC
3051 * Measurement Info finally subscribed
3052 * Memory failure indicator
3053 * @return ROK - success
3056 ******************************************************************/
3057 uint8_t extractMeasInfoList(CmLListCp *measInfoSupportedList, MeasurementInfoList_t *measInfoToBeSubscribedList, \
3058 CmLListCp *measInfoSubscribedList, bool *memFailure)
3060 uint8_t elementIdx = 0;
3061 MeasurementInfoForAction *measInfoSupportedDb = NULLP;
3062 MeasurementInfo *measInfoSubscribedDb = NULLP;
3063 CmLList *supportedMeasNode = NULLP, *measToAddNode = NULLP;
3064 MeasurementInfoItem_t *measItem = NULLP;
3066 /* Validate Measurement list is supported by E2 node.
3068 * Traverse and compare the Measurement-Supported List in E2
3069 * node with Measurement-to-be-subscribed list received from RIC.
3070 * If a match is found, add it to measurement-subscription list.
3072 for(elementIdx = 0; elementIdx < measInfoToBeSubscribedList->list.count; elementIdx++)
3074 measInfoSubscribedDb = NULLP;
3075 measToAddNode = NULLP;
3076 measItem = measInfoToBeSubscribedList->list.array[elementIdx];
3078 CM_LLIST_FIRST_NODE(measInfoSupportedList, supportedMeasNode);
3079 while(supportedMeasNode)
3081 measInfoSupportedDb = (MeasurementInfoForAction*)supportedMeasNode->node;
3082 switch(measItem->measType.present)
3084 case MeasurementType_PR_measName:
3086 if(!strcmp(measInfoSupportedDb->measurementTypeName, (char *)measItem->measType.choice.measName.buf))
3088 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
3093 case MeasurementType_PR_measID:
3095 if(measInfoSupportedDb->measurementTypeId == measItem->measType.choice.measID)
3097 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
3104 DU_LOG("\nERROR -> DUAPP: Invalid Measurement-type identifier in \
3105 E2SM-KPM Action Definition Format");
3108 } /* End of switch, for measurement type identifier */
3110 /* If measurement type is supported, add to measurement-subscription list */
3111 if(measInfoSubscribedDb)
3113 measInfoSubscribedDb->measurementTypeId = measInfoSupportedDb->measurementTypeId;
3114 memcpy(measInfoSubscribedDb->measurementTypeName, measInfoSupportedDb->measurementTypeName, \
3115 strlen(measInfoSupportedDb->measurementTypeName));
3117 DU_ALLOC(measToAddNode, sizeof(CmLList));
3120 measToAddNode->node = (PTR) measInfoSubscribedDb;
3121 cmLListAdd2Tail(measInfoSubscribedList, measToAddNode);
3123 /* Break out of while loop if measurement info is found in measurement-supported list */
3128 DU_FREE(measInfoSubscribedDb, sizeof(MeasurementInfo));
3129 measInfoSubscribedDb = NULLP;
3135 supportedMeasNode = supportedMeasNode->next;
3137 } /* End of while for traversing measurement-supported list in a report style */
3139 /* If a measurement-to-be-subscribed is not found in measurement-supported list in this report style
3141 * Delete all entries from measurement-subscription list and
3142 * Break out of for loop to search in next report style */
3143 if(!measInfoSubscribedDb)
3145 deleteMeasurementInfoList(measInfoSubscribedList);
3149 } /* End of for loop , traversing measurement-to-be-subscribed list */
3151 /* If all measurement-to-be-subscribed was found in measurement-supported list and
3152 * was added to measurement-subscription list successfully, return from here */
3153 if(measInfoToBeSubscribedList->list.count == measInfoSubscribedList->count)
3159 /*******************************************************************
3161 * @brief Extract E2SM-KPM Action definition
3165 * Function : extractRicActionDef
3167 * Functionality : This function :
3168 * - Decodes E2SM-KPM Action Definition
3169 * - Validates that action is supported by E2 node
3170 * - Stores action details in local DB
3172 * @params[in] RAN Function Database structure
3173 * RIC subscription's Action definition to be added to
3175 * RIC Action Definition buffer received from RIC
3176 * @return ROK - success
3179 ******************************************************************/
3180 uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefDb, RICactionDefinition_t *ricActionDef,\
3181 E2FailureCause *failureCause)
3183 bool memFailure = false;
3184 uint8_t styleIdx = 0;
3185 asn_dec_rval_t rval ={0};
3187 E2SM_KPM_ActionDefinition_t actionDef, *actionDefPtr = NULLP;
3188 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
3189 CmLListCp *measInfoSupportedList = NULLP;
3190 CmLListCp *measInfoSubscribedList = NULLP;
3192 /* Decoding E2SM-KPM Action Definition */
3193 actionDefPtr = &actionDef;
3194 memset(actionDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
3196 rval = aper_decode(0, &asn_DEF_E2SM_KPM_ActionDefinition, (void **)&actionDefPtr, ricActionDef->buf,\
3197 ricActionDef->size, 0, 0);
3198 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
3200 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Action Definition");
3201 failureCause->causeType = E2_PROTOCOL;
3202 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
3206 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDefPtr);
3209 /* Validate if Report style to subscribe is supported by E2 Node */
3210 for(styleIdx= 0; styleIdx < ranFuncDb->numOfReportStyleSupported; styleIdx++)
3212 /* Validate Report style type and report style format type is supported by E2 Node */
3213 if((ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType == actionDefPtr->ric_Style_Type) &&
3214 (ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType == actionDefPtr->actionDefinition_formats.present))
3216 /* Fetch Report stype type and format type */
3217 actionDefDb->styleType = actionDefPtr->ric_Style_Type;
3218 actionDefDb->formatType = actionDefPtr->actionDefinition_formats.present;
3220 switch(actionDefPtr->actionDefinition_formats.present)
3222 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
3224 actionFormat1 = actionDefPtr->actionDefinition_formats.choice.actionDefinition_Format1;
3226 /* Fetch granularity period */
3227 actionDefDb->choice.format1.granularityPeriod = actionFormat1->granulPeriod;
3229 /* Validate and add the Measurement to subscription list */
3230 measInfoSupportedList = &ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
3231 measInfoSubscribedList = &actionDefDb->choice.format1.measurementInfoList;
3232 if(extractMeasInfoList(measInfoSupportedList, &actionFormat1->measInfoList, \
3233 measInfoSubscribedList, &memFailure) == ROK)
3237 /* Free E2SM_KPM_ActionDefinition_t */
3238 freeAperDecodingOfRicActionDefinition(actionDefPtr);
3243 break; /* End of E2SM-KPM Action definition format 1 case */
3248 DU_LOG("\nERROR -> DUAPP: Only E2SM-KPM Action Definition Format 1 is supported");
3251 } /* End of switch for E2SM-KPM Action definition formats */
3256 failureCause->causeType = E2_MISCELLANEOUS;
3257 failureCause->cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3260 } /* End of for loop, traversing Report-styles-supported list in E2 node */
3262 /* Memset action Db and Free E2SM_KPM_ActionDefinition_t */
3263 memset(actionDefDb, 0, sizeof(ActionDefinition));
3264 freeAperDecodingOfRicActionDefinition(actionDefPtr);
3266 if(failureCause->causeType == E2_NOTHING)
3268 failureCause->causeType = E2_RIC_REQUEST;
3269 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3274 /*******************************************************************
3276 * @brief add RIC Subs action info
3280 * Function : addRicSubsAction
3282 * Functionality: add Ric Subs action info
3286 * Pointer to Ric Subc info
3287 * Action Sequence list
3290 * @return ROK - success
3293 ******************************************************************/
3295 CmLList *addRicSubsAction(RanFunction *ranFuncDb, PTR ricSubsInfo, CmLListCp *actionSequence, uint8_t procedureCode, E2FailureCause *failureCause)
3297 CmLList *actionNode = NULLP;
3298 ActionInfo *actionDb = NULLP;
3299 RICactionID_t ricActionID;
3300 RICactionType_t ricActionType;
3301 RICactionDefinition_t *ricActionDefinition= NULLP;
3302 RICaction_ToBeSetup_Item_t *setupItem= NULLP;
3303 RICaction_ToBeAddedForModification_Item_t *addIem= NULLP;
3304 RICaction_ToBeModifiedForModification_Item_t *modifiedItem= NULLP;
3306 switch(procedureCode)
3308 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
3310 setupItem = (RICaction_ToBeSetup_Item_t *)ricSubsInfo;
3311 ricActionID= setupItem->ricActionID;
3312 ricActionType= setupItem->ricActionType;
3313 if(setupItem->ricActionDefinition)
3315 ricActionDefinition = setupItem->ricActionDefinition;
3319 case ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item:
3321 addIem = (RICaction_ToBeAddedForModification_Item_t*) ricSubsInfo;
3322 ricActionID= addIem->ricActionID;
3323 ricActionType= addIem->ricActionType;
3324 ricActionDefinition = &addIem->ricActionDefinition;
3328 case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item:
3330 modifiedItem= (RICaction_ToBeModifiedForModification_Item_t*)ricSubsInfo;
3331 ricActionID= modifiedItem->ricActionID;
3332 /* Added since ricActionType IE is not present in case of
3334 ricActionType = RICactionType_report;
3335 if(modifiedItem->ricActionDefinition)
3337 ricActionDefinition = modifiedItem->ricActionDefinition;
3344 DU_ALLOC(actionDb, sizeof(ActionInfo));
3347 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
3350 if(ricActionType== RICactionType_report)
3352 actionDb->actionId = ricActionID;
3353 actionDb->type = REPORT;
3355 if(extractRicActionDef(ranFuncDb, &actionDb->definition, ricActionDefinition, failureCause) == ROK)
3357 actionDb->action = CONFIG_ADD;
3360 DU_ALLOC(actionNode, sizeof(CmLList));
3363 actionNode->node = (PTR) actionDb;
3364 cmLListAdd2Tail(actionSequence, actionNode);
3368 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
3369 DU_FREE(actionDb, sizeof(ActionInfo));
3376 /*******************************************************************
3378 * @brief Extract RIC Action to be setup
3382 * Function : extractRicActionToBeSetup
3384 * Functionality : This function :
3385 * - Validates that each action-to-be-setup is supported by E2 node
3386 * - Stores event trigger details in local DB
3388 * @params[in] RAN Function Database structure
3389 * RIC Subscription Info to be added to RAN function
3390 * RIC Action To Be Setup List received from RIC
3391 * @return ROK - success
3394 ******************************************************************/
3395 uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
3396 RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause, PendingSubsRspInfo *subsRsp)
3398 CmLList *actionNode = NULLP;
3399 uint8_t actionIdx = 0;
3400 uint8_t ricActionId = 0;
3401 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
3403 if(actionList->list.array)
3405 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
3407 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)actionList->list.array[actionIdx];
3408 switch(actionItem->id)
3410 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
3412 /* If Action type is REPORT and
3413 * If RIC action definition's extraction and validation passes,
3415 * This action is added to action sequence list of subscription info */
3416 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeSetup_Item,\
3417 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item, failureCause);
3421 /* In case of any failure, action is rejected
3422 * Added to rejected-action-list in subscription response */
3423 subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId;
3424 if(failureCause->causeType == E2_NOTHING)
3426 failureCause->causeType = E2_RIC_REQUEST;
3427 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
3429 memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \
3430 failureCause, sizeof(E2FailureCause));
3431 subsRsp->numOfRejectedActions++;
3436 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
3442 /* If there is even 1 action that can be added, return ROK */
3443 if(ricSubscriptionInfo->actionSequence.count)
3446 if(failureCause->causeType == E2_NOTHING)
3448 failureCause->causeType = E2_RIC_REQUEST;
3449 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3454 /******************************************************************
3456 * @brief Processes RIC Subscription Req sent by RIC
3460 * Function : procRicSubscriptionRequest
3462 * Functionality: Processes RIC Subscription Request from RIC
3464 * @params[in] E2AP_PDU_t ASN decoded E2AP message
3465 * @return ROK - success
3468 * ****************************************************************/
3469 uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg)
3473 uint16_t ranFuncId = 0;
3474 RicRequestId ricReqId;
3475 CmLList *ricSubscriptionNode = NULLP;
3476 RanFunction *ranFuncDb = NULLP;
3477 RICsubscriptionRequest_t *ricSubsReq = NULLP;
3478 RICsubscriptionDetails_t *subsDetails = NULLP;
3479 RicSubscription *ricSubscriptionInfo = NULLP;
3480 E2FailureCause failureCause;
3482 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
3484 memset(&failureCause, 0, sizeof(E2FailureCause));
3485 memset(&ricReqId, 0, sizeof(RicRequestId));
3487 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
3488 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
3490 if(ricSubsReq->protocolIEs.list.array[idx])
3492 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
3494 case ProtocolIE_IDE2_id_RICrequestID:
3496 ricReqId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID;
3497 ricReqId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID;
3502 case ProtocolIE_IDE2_id_RANfunctionID:
3504 ranFuncId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID;
3506 /* Validating RAN Function id */
3507 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
3511 failureCause.causeType = E2_RIC_REQUEST;
3512 failureCause.cause = E2_RAN_FUNCTION_ID_INVALID;
3517 if(ranFuncDb->numPendingSubsRsp >= MAX_PENDING_SUBSCRIPTION_RSP)
3519 failureCause.causeType = E2_RIC_REQUEST;
3520 failureCause.cause = E2_FUNCTION_RESOURCE_LIMIT;
3525 DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription));
3526 if(!ricSubscriptionInfo)
3528 DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
3529 failureCause.causeType = E2_MISCELLANEOUS;
3530 failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3534 ricSubscriptionInfo->requestId.requestorId = ricReqId.requestorId;
3535 ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId;
3536 ricSubscriptionInfo->ranFuncId = ranFuncId;
3538 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3539 memcpy(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].requestId,
3540 &ricReqId, sizeof(RicRequestId));
3541 ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].ranFuncId = ranFuncId;
3545 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
3547 subsDetails = &ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails;
3549 /* Decode, Validate and record Event Trigger Definition */
3550 if(extractEventTriggerDef(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricEventTriggerDefinition, \
3551 &failureCause) != ROK)
3557 /* Decode, Validate and record RIC actions */
3558 if(extractRicActionToBeSetup(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricAction_ToBeSetup_List, \
3559 &failureCause, &ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp]) != ROK)
3568 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
3569 ricSubsReq->protocolIEs.list.array[idx]->id);
3578 freeAperDecodingOfRicSubsReq(ricSubsReq);
3582 cmInitTimers(&(ricSubscriptionInfo->ricSubsReportTimer), 1);
3583 ricSubscriptionInfo->action = CONFIG_ADD;
3585 /* Add RAN subcription detail to RAN function */
3586 DU_ALLOC(ricSubscriptionNode, sizeof(CmLList));
3587 if(ricSubscriptionNode)
3589 ricSubscriptionNode->node = (PTR) ricSubscriptionInfo;
3590 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubscriptionNode);
3593 ranFuncDb->numPendingSubsRsp++;
3595 /* Send statistics request to other DU entities */
3596 BuildAndSendStatsReq(ricSubscriptionInfo);
3600 DU_FREE(ricSubscriptionInfo, sizeof(RicSubscription));
3604 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3607 /* Send RIC Subcription Failure */
3608 BuildAndSendRicSubscriptionFailure(ricReqId, ranFuncId, failureCause);
3613 /******************************************************************
3615 * @brief Free RIC Subscription Failure
3619 * Function : FreeRicSubscriptionFailure
3621 * Functionality: Free RIC Subscription Failure
3623 * @params[in] E2AP PDU
3626 * ****************************************************************/
3627 void FreeRicSubscriptionFailure(E2AP_PDU_t *e2apMsg)
3629 uint8_t elemIdx = 0;
3630 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3634 if(e2apMsg->choice.unsuccessfulOutcome)
3636 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3637 if(ricSubscriptionFailure->protocolIEs.list.array)
3639 for(elemIdx = 0; elemIdx < ricSubscriptionFailure->protocolIEs.list.count; elemIdx++)
3641 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3643 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3645 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3647 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3651 /******************************************************************
3653 * @brief Fill and Send RIC Subscription Failure to RIC
3657 * Function : BuildAndSendRicSubscriptionFailure
3659 * Functionality: Fill and Send RIC Subscription Failure to RIC
3661 * @params[in] RIC Request ID
3664 * @return ROK - success
3667 * ****************************************************************/
3668 uint8_t BuildAndSendRicSubscriptionFailure(RicRequestId ricReqId, uint16_t ranFuncId, E2FailureCause failureCause)
3670 uint8_t ret = RFAILED;
3671 uint8_t elementCnt = 0, elemIdx = 0;
3672 E2AP_PDU_t *e2apMsg = NULLP;
3673 asn_enc_rval_t encRetVal; /* Encoder return value */
3674 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3675 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3679 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Failure\n");
3681 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3682 if(e2apMsg == NULLP)
3684 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3688 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3689 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3690 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3692 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3695 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
3696 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3697 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure;
3699 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3702 ricSubscriptionFailure->protocolIEs.list.count = elementCnt;
3703 ricSubscriptionFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionFailure_IEs_t *);
3704 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3705 if(!ricSubscriptionFailure->protocolIEs.list.array)
3707 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3711 for(elemIdx = 0; elemIdx < elementCnt; elemIdx++)
3713 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3714 if(!ricSubscriptionFailure->protocolIEs.list.array[elemIdx])
3716 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d] for IE at index [%d]", \
3717 __func__, __LINE__, elemIdx);
3721 if(elemIdx < elementCnt)
3726 /* RIC Request ID */
3727 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3728 ricSubsFailIe->id = ProtocolIE_IDE2_id_RICrequestID;
3729 ricSubsFailIe->criticality = CriticalityE2_reject;
3730 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
3731 ricSubsFailIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3732 ricSubsFailIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3734 /* RAN Function ID */
3735 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3736 ricSubsFailIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3737 ricSubsFailIe->criticality = CriticalityE2_reject;
3738 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
3739 ricSubsFailIe->value.choice.RANfunctionID = ranFuncId;
3742 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3743 ricSubsFailIe->id = ProtocolIE_IDE2_id_CauseE2;
3744 ricSubsFailIe->criticality = CriticalityE2_reject;
3745 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_CauseE2;
3746 fillE2Cause(&ricSubsFailIe->value.choice.CauseE2, failureCause);
3748 /* Prints the Msg formed */
3749 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3750 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3752 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3753 if(encRetVal.encoded == ENCODE_FAIL)
3755 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Failure Message (at %s)\n",\
3756 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3761 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Failure Message \n");
3762 #ifdef DEBUG_ASN_PRINT
3763 for(int i=0; i< encBufSize; i++)
3765 printf("%x",encBuf[i]);
3770 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
3772 DU_LOG("\nINFO --> E2AP : Sending RIC Subscription Failure");
3778 FreeRicSubscriptionFailure(e2apMsg);
3782 /*******************************************************************
3784 * @brief Free the RicIndication Message
3788 * Function : FreeRicIndication
3790 * Functionality: Free the RicIndication Message
3795 ******************************************************************/
3796 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
3799 RICindication_t *ricIndicationMsg= NULLP;
3801 if(e2apMsg != NULLP)
3803 if(e2apMsg->choice.initiatingMessage != NULLP)
3805 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
3806 if(ricIndicationMsg!= NULLP)
3808 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
3810 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
3812 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
3814 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
3816 case ProtocolIE_IDE2_id_RICrequestID:
3817 case ProtocolIE_IDE2_id_RANfunctionID:
3818 case ProtocolIE_IDE2_id_RICactionID:
3819 case ProtocolIE_IDE2_id_RICindicationType:
3822 case ProtocolIE_IDE2_id_RICindicationHeader:
3824 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
3825 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
3828 case ProtocolIE_IDE2_id_RICindicationMessage:
3830 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
3831 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
3837 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
3840 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
3843 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3845 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3849 /*******************************************************************
3851 * @brief Free measurement record
3855 * Function : freeMeasRecord
3857 * Functionality: Free all measurement recorded for a measurement
3858 * within an action in a RIC subscription
3860 * @param Measurement data to be freed
3863 ******************************************************************/
3864 void freeMeasData(MeasurementData_t *measData)
3866 uint8_t measIdx = 0, measRecIdx = 0;
3867 MeasurementRecord_t *measRecord = NULLP;
3869 if(measData->list.array)
3871 for(measIdx = 0; measIdx < measData->list.count; measIdx++)
3873 if(measData->list.array[measIdx])
3875 measRecord = &measData->list.array[measIdx]->measRecord;
3876 if(measRecord->list.array)
3878 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3880 DU_FREE(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3882 DU_FREE(measRecord->list.array, measRecord->list.size);
3884 DU_FREE(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
3887 DU_FREE(measData->list.array, measData->list.size);
3891 /*******************************************************************
3893 * @brief Fill measurement info list
3897 * Function : freeMeasInfoList
3899 * Functionality: Fills all measurement info within an action
3900 * in a RIC subscription
3902 * @param Measurement Info list to be freed
3905 ******************************************************************/
3906 void freeMeasInfoList(MeasurementInfoList_t *measInfoList)
3908 uint8_t measInfoIdx = 0;
3910 if(measInfoList->list.array)
3912 for(measInfoIdx = 0; measInfoIdx < measInfoList->list.count; measInfoIdx++)
3914 if(measInfoList->list.array[measInfoIdx])
3916 DU_FREE(measInfoList->list.array[measInfoIdx]->measType.choice.measName.buf, \
3917 measInfoList->list.array[measInfoIdx]->measType.choice.measName.size);
3919 DU_FREE(measInfoList->list.array[measInfoIdx], measInfoList->list.size);
3922 DU_FREE(measInfoList->list.array, measInfoList->list.size);
3926 /*******************************************************************
3928 * @brief Free E2SM-KPM Indication Message
3932 * Function : FreeE2smKpmIndicationMessage
3934 * Functionality: Free E2SM-KPM Indication Message
3936 * @param E2SM-KPM Indication message to be freed
3939 ******************************************************************/
3940 void FreeE2smKpmIndicationMessage(E2SM_KPM_IndicationMessage_t *e2smKpmIndMsg)
3942 E2SM_KPM_IndicationMessage_Format1_t *format1Msg = NULLP;
3944 switch(e2smKpmIndMsg->indicationMessage_formats.present)
3946 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
3948 if(e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1)
3950 format1Msg = e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1;
3952 /* Measurement Data */
3953 freeMeasData(&format1Msg->measData);
3955 /* Measurement Info List */
3956 if(format1Msg->measInfoList)
3958 freeMeasInfoList(format1Msg->measInfoList);
3959 DU_FREE(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
3962 /* Granularity Period */
3963 DU_FREE(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
3965 DU_FREE(format1Msg, sizeof(E2SM_KPM_IndicationMessage_Format1_t));
3970 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
3971 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
3977 /*******************************************************************
3979 * @brief Fill measurement record
3983 * Function : fillMeasRecord
3985 * Functionality: Fills all measurement value for a measurement
3986 * within an action in a RIC subscription
3988 * @param Measurement record to be filled
3989 * Measurement database with measurement records
3990 * @return ROK - success
3993 ******************************************************************/
3994 uint8_t fillMeasRecord(MeasurementRecord_t *measRecord, MeasurementInfo *measInfoDb)
3996 uint8_t measRecIdx = 0;
3997 CmLList *measValNode = NULLP;
4000 measRecord->list.count = measInfoDb->measuredValue.count;
4001 measRecord->list.size = measRecord->list.count * sizeof(MeasurementRecordItem_t *);
4003 DU_ALLOC(measRecord->list.array, measRecord->list.size);
4004 if(!measRecord->list.array)
4006 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4010 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
4012 DU_ALLOC(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
4013 if(!measRecord->list.array[measRecIdx])
4015 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4021 CM_LLIST_FIRST_NODE(&measInfoDb->measuredValue, measValNode);
4024 measVal = *(double *)measValNode->node;
4025 if(measVal == (int)measVal)
4027 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_integer;
4028 measRecord->list.array[measRecIdx]->choice.integer = (int)measVal;
4032 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_real;
4033 measRecord->list.array[measRecIdx]->choice.real = measVal;
4036 measValNode= measValNode->next;
4037 /* Once the measurement record is added to the message, delete it from DB */
4040 deleteMeasuredValueList(&measInfoDb->measuredValue);
4044 /*******************************************************************
4046 * @brief Fills measuerement data
4050 * Function : fillMeasData
4052 * Functionality: Fill all measurement recorded for all measurements
4053 * in an action in a RIC subscription
4055 * @param Measurement data to be filled
4056 * Measurement info list from an action DB
4057 * @return ROK - success
4060 ******************************************************************/
4061 uint8_t fillMeasData(MeasurementData_t *measData, CmLListCp *measInfoListDb)
4063 uint8_t measIdx = 0;
4064 CmLList *measInfoNode = NULLP;
4065 MeasurementInfo *measInfoDb = NULLP;
4066 MeasurementRecord_t *measRecord = NULLP;
4068 measData->list.count = measInfoListDb->count;
4069 measData->list.size = measData->list.count * sizeof(MeasurementDataItem_t *);
4071 DU_ALLOC(measData->list.array, measData->list.size);
4072 if(!measData->list.array)
4074 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4079 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4082 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4085 DU_ALLOC(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
4086 if(!measData->list.array[measIdx])
4088 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4092 measRecord = &measData->list.array[measIdx]->measRecord;
4093 if(fillMeasRecord(measRecord, measInfoDb) != ROK)
4095 DU_LOG("\nERROR --> E2AP : Failed to fill measurement record");
4100 measInfoNode = measInfoNode->next;
4106 /*******************************************************************
4108 * @brief Fill all measurement info
4112 * Function : fillMeasInfoList
4114 * Functionality: Fills all measurement info belonging to an action
4115 * in a RIC subscription
4117 * @param Measurement Info list to be filled
4118 * Measurement Info list from E2AP DB
4119 * @return ROK - success
4122 ******************************************************************/
4123 uint8_t fillMeasInfoList(MeasurementInfoList_t *measInfoList, CmLListCp *measInfoListDb)
4125 uint8_t measInfoIdx = 0;
4126 CmLList *measInfoNode = NULLP;
4127 MeasurementInfo *measInfoDb = NULLP;
4128 MeasurementInfoItem_t *measInfoItem = NULLP;
4130 measInfoList->list.count = measInfoListDb->count;
4131 measInfoList->list.size = measInfoList->list.count * sizeof(MeasurementInfoItem_t *);
4133 DU_ALLOC(measInfoList->list.array, measInfoList->list.size);
4134 if(!measInfoList->list.array)
4136 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4141 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4144 DU_ALLOC(measInfoList->list.array[measInfoIdx], sizeof(MeasurementInfoItem_t));
4145 if(!measInfoList->list.array[measInfoIdx])
4147 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4151 measInfoItem = measInfoList->list.array[measInfoIdx];
4152 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4155 /* Measurement Type */
4156 measInfoItem->measType.present = MeasurementType_PR_measName;
4157 measInfoItem->measType.choice.measName.size = strlen(measInfoDb->measurementTypeName);
4159 DU_ALLOC(measInfoItem->measType.choice.measName.buf, measInfoItem->measType.choice.measName.size);
4160 if(!measInfoItem->measType.choice.measName.buf)
4162 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4166 memcpy(measInfoItem->measType.choice.measName.buf, measInfoDb->measurementTypeName,\
4167 measInfoItem->measType.choice.measName.size);
4171 measInfoNode = measInfoNode->next;
4178 /*******************************************************************
4180 * @brief Fill E2SM-KPM Indication Message Format 1
4184 * Function : fillE2smKpmIndMsgFormat1
4186 * Functionality: Fill E2SM-KPM Indication Message Format 1
4188 * @param Format 1 Message to be filled
4189 * Action Definition format 1 from E2AP DB
4190 * @return ROK - success
4193 ******************************************************************/
4194 uint8_t fillE2smKpmIndMsgFormat1(E2SM_KPM_IndicationMessage_Format1_t *format1Msg, ActionDefFormat1 *format1)
4196 /* Measurement Data */
4197 if(fillMeasData(&format1Msg->measData, &format1->measurementInfoList) != ROK)
4199 DU_LOG("\nERROR --> E2AP : Failed to fill measurement data");
4203 /* Measurement Information */
4204 DU_ALLOC(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
4205 if(!format1Msg->measInfoList)
4207 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4211 if(fillMeasInfoList(format1Msg->measInfoList, &format1->measurementInfoList) != ROK)
4213 DU_LOG("\nERROR --> E2AP : Failed to fill measurement information list");
4217 /* Granularity Period */
4218 DU_ALLOC(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
4219 if(!format1Msg->granulPeriod)
4221 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4224 *(format1Msg->granulPeriod) = format1->granularityPeriod;
4229 /*******************************************************************
4231 * @brief Fill RIC Indication Message buffer
4235 * Function : fillRicIndMsgBuf
4237 * Functionality: Fill E2SM-KPM Indication Message
4238 * Encode this message and copy to RIC Indication Message buffer
4240 * @param RIC Indication Message buffer to be filled
4241 * Source action info from E2AP DB
4242 * @return ROK - success
4245 ******************************************************************/
4246 uint8_t fillRicIndMsgBuf(RICindicationMessage_t *ricIndMsgBuf, ActionInfo *actionInfo)
4248 uint8_t ret = RFAILED;
4249 bool failedInFormat = false;
4250 E2SM_KPM_IndicationMessage_t e2smKpmIndMsg;
4251 asn_enc_rval_t encRetVal; /* Encoder return value */
4253 memset(&e2smKpmIndMsg, 0, sizeof(E2SM_KPM_IndicationMessage_t));
4257 /* E2SM-KPM Indication message format type */
4258 e2smKpmIndMsg.indicationMessage_formats.present = actionInfo->definition.formatType;
4259 switch(e2smKpmIndMsg.indicationMessage_formats.present)
4261 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
4263 /* E2SM-KPM Indication message format 1 */
4264 DU_ALLOC(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4265 sizeof(E2SM_KPM_IndicationMessage_Format1_t));
4266 if(!e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1)
4268 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4269 failedInFormat = true;
4273 if(fillE2smKpmIndMsgFormat1(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4274 &actionInfo->definition.choice.format1) != ROK)
4276 DU_LOG("\nERROR --> E2AP : Failed to fill E2SM-KPM Indication message format 1");
4277 failedInFormat = true;
4283 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
4284 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
4287 DU_LOG("\nERROR --> E2AP : fillRicIndMsgBuf: Only Format 1 supported");
4288 failedInFormat = true;
4296 /* Encode E2SM-KPM Indication Message */
4297 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationMessage, &e2smKpmIndMsg);
4298 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4300 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationMessage, 0, &e2smKpmIndMsg, PrepFinalEncBuf, encBuf);
4301 if(encRetVal.encoded == ENCODE_FAIL)
4303 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Message (at %s)\n",\
4304 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4309 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Message \n");
4310 #ifdef DEBUG_ASN_PRINT
4311 for(int i=0; i< encBufSize; i++)
4313 printf("%x",encBuf[i]);
4318 /* Copy encoded string to RIC Indication Message buffer */
4319 ricIndMsgBuf->size = encBufSize;
4320 DU_ALLOC(ricIndMsgBuf->buf, ricIndMsgBuf->size);
4321 if(!ricIndMsgBuf->buf)
4323 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4326 memset(ricIndMsgBuf->buf, 0, ricIndMsgBuf->size);
4327 memcpy(ricIndMsgBuf->buf, encBuf, encBufSize);
4333 /* Free E2SM-KPM Indication Message */
4334 FreeE2smKpmIndicationMessage(&e2smKpmIndMsg);
4339 /*******************************************************************
4341 * @brief Free E2SM-KPM Indication Header
4345 * Function : FreeE2smKpmIndicationHeader
4347 * Functionality: Free E2SM-KPM Indication Header
4349 * @param E2SM-KPM Indication Header to be free
4352 ******************************************************************/
4353 void FreeE2smKpmIndicationHeader(E2SM_KPM_IndicationHeader_t *e2smKpmIndHdr)
4355 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4359 switch(e2smKpmIndHdr->indicationHeader_formats.present)
4361 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4363 if(e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1)
4365 format1 = e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1;
4367 DU_FREE(format1->colletStartTime.buf, format1->colletStartTime.size);
4368 DU_FREE(format1, sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4372 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4379 /*******************************************************************
4381 * @brief Fill RIC Indication Header buffer
4385 * Function : fillRicIndHeader
4387 * Functionality: Fill E2SM-KPM Indication Header
4388 * Encode this message and copy to RIC Indication Header buffer
4390 * @param RIC Indication Header buffer to be filled
4391 * Source RIC subscription info from E2AP DB
4392 * @return ROK - success
4395 ******************************************************************/
4396 uint8_t fillRicIndHeader(RICindicationHeader_t *ricIndHdr, RicSubscription *ricSubsInfo)
4398 uint8_t ret = RFAILED;
4399 uint8_t secBufIdx = 0, milliSecBufIdx = 0;
4401 bool formatFailure = false;
4402 RanFunction *ranFunc = NULLP;
4403 ReportStartTime *startTime = NULLP;
4404 E2SM_KPM_IndicationHeader_t e2smKpmIndHdr;
4405 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4406 asn_enc_rval_t encRetVal; /* Encoder return value */
4410 ranFunc = fetchRanFuncFromRanFuncId(ricSubsInfo->ranFuncId);
4411 if(ranFunc == NULLP)
4413 DU_LOG("\nERROR --> E2AP : RAN Function ID [%d] not found", ricSubsInfo->ranFuncId);
4417 memset(&e2smKpmIndHdr, 0, sizeof(E2SM_KPM_IndicationHeader_t));
4419 e2smKpmIndHdr.indicationHeader_formats.present = ranFunc->ricIndicationHeaderFormat;
4420 switch(e2smKpmIndHdr.indicationHeader_formats.present)
4422 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4424 DU_ALLOC(e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1, \
4425 sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4426 if(!e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1)
4428 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4429 formatFailure = true;
4432 format1 = e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1;
4434 /* Fetch reporting period start time from DB */
4435 switch(ricSubsInfo->eventTriggerDefinition.formatType)
4439 startTime = &ricSubsInfo->eventTriggerDefinition.choice.format1.startTime;
4443 format1->colletStartTime.size = 8 * sizeof(uint8_t);
4444 DU_ALLOC(format1->colletStartTime.buf, format1->colletStartTime.size);
4445 if(!format1->colletStartTime.buf)
4447 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4448 formatFailure = true;
4452 /* As per O-RAN.WG3.E2SM-KPM-R003-v03.00, section 8.3.12 and
4453 * RFC 5905, section 6 :
4454 * Time stamp has a 64-bit format where first 32-bit is seconds
4455 * and next 32-bit is fraction in picosecond-level.
4456 * This fraction has been rounded in microseconds.
4459 * Storing 32-bit seconds at MSB 0-3 and
4460 * 32-bit milliseconds at next 4 bytes i.e. bytes 4-7
4464 for(byteIdx = 3; byteIdx >= 0; byteIdx--)
4466 format1->colletStartTime.buf[secBufIdx++] = startTime->timeInSec >> (8*byteIdx);
4467 format1->colletStartTime.buf[milliSecBufIdx++] = startTime->timeInMilliSec >> (8*byteIdx);
4472 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4475 DU_LOG("\nERROR --> E2AP : Only E2SM-KPM Indication Header Format 1 supported");
4476 formatFailure = true;
4484 /* Encode E2SM-KPM Indication Header */
4485 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationHeader, &e2smKpmIndHdr);
4486 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4488 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationHeader, 0, &e2smKpmIndHdr, PrepFinalEncBuf, encBuf);
4489 if(encRetVal.encoded == ENCODE_FAIL)
4491 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Header (at %s)\n",\
4492 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4497 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Header \n");
4498 #ifdef DEBUG_ASN_PRINT
4499 for(int i=0; i< encBufSize; i++)
4501 printf("%x",encBuf[i]);
4506 /* Copy encoded string to RIC Indication Header buffer */
4507 ricIndHdr->size = encBufSize;
4508 DU_ALLOC(ricIndHdr->buf, ricIndHdr->size);
4511 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4514 memset(ricIndHdr->buf, 0, ricIndHdr->size);
4515 memcpy(ricIndHdr->buf, encBuf, encBufSize);
4520 /* Free E2SM-KPM Indication Header */
4521 FreeE2smKpmIndicationHeader(&e2smKpmIndHdr);
4526 /*******************************************************************
4528 * brief Fill the RIC Indication Message
4532 * Function : fillRicIndication
4534 * Functionality: Fills the RIC Indication Message
4536 * @param RIC Indication Message to be filled
4537 * RIC Subscription DB
4539 * @return ROK - success
4542 ******************************************************************/
4543 uint8_t fillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4545 uint8_t elementCnt = 0, idx = 0;
4550 ricIndicationMsg->protocolIEs.list.count = elementCnt;
4551 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_IEs_t *);
4553 /* Initialize the Ric Indication members */
4554 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, ricIndicationMsg->protocolIEs.list.size);
4555 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
4557 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4561 for(idx=0; idx<elementCnt; idx++)
4563 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx], sizeof(RICindication_IEs_t));
4564 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
4566 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4571 /* RIC Request ID */
4573 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
4574 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4575 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICrequestID;
4576 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = \
4577 ricSubscriptionInfo->requestId.requestorId;
4578 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = \
4579 ricSubscriptionInfo->requestId.instanceId;
4581 /* RAN Function ID */
4583 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
4584 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4585 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RANfunctionID;
4586 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ricSubscriptionInfo->ranFuncId;
4590 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
4591 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4592 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICactionID;
4593 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = actionInfo->actionId;
4595 /* RIC Indication Type */
4597 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
4598 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4599 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationType;
4600 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = actionInfo->type;
4602 /* RIC Indication Header */
4604 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
4605 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4606 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationHeader;
4607 if(fillRicIndHeader(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader, \
4608 ricSubscriptionInfo) != ROK)
4610 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication header");
4614 /* RIC Indication Message */
4616 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
4617 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4618 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationMessage;
4619 if(fillRicIndMsgBuf(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage, \
4622 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication Message");
4629 /*******************************************************************
4631 * @brief Builds and Send the RicIndication Message
4635 * Function : BuildAndSendRicIndication
4637 * Functionality:Fills the RicIndication Message
4639 * @return ROK - success
4642 ******************************************************************/
4644 uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4646 uint8_t ret = RFAILED;
4647 E2AP_PDU_t *e2apMsg = NULLP;
4648 RICindication_t *ricIndicationMsg = NULLP;
4649 asn_enc_rval_t encRetVal; /* Encoder return value */
4653 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
4655 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4656 if(e2apMsg == NULLP)
4658 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4662 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4663 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4664 if(e2apMsg->choice.initiatingMessage == NULLP)
4666 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4669 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
4670 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4671 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
4673 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
4675 if(fillRicIndication(ricIndicationMsg, ricSubscriptionInfo, actionInfo) != ROK)
4677 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication message");
4681 /* Prints the Msg formed */
4682 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4683 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4685 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4687 if(encRetVal.encoded == ENCODE_FAIL)
4689 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
4690 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4695 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
4696 #ifdef DEBUG_ASN_PRINT
4697 for(int i=0; i< encBufSize; i++)
4699 printf("%x",encBuf[i]);
4704 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
4706 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
4712 FreeRicIndication(e2apMsg);
4716 /*******************************************************************
4718 * @brief free e2 node component configuration req and rsp
4722 * Function : freeE2NodeComponentConfiguration
4725 * - free e2 node component configuration req and rsp
4727 * @params[in] E2nodeComponentConfiguration_t *e2nodeComponentConfiguration
4728 * @return ROK - success
4731 * ****************************************************************/
4733 void freeE2NodeComponentConfiguration(E2nodeComponentConfiguration_t *e2nodeComponentConfiguration)
4735 /* Free E2 Node Component Request Part */
4736 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentRequestPart.buf, e2nodeComponentConfiguration->e2nodeComponentRequestPart.size);
4738 /* Free E2 Node Component Response Part */
4739 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentResponsePart.buf, e2nodeComponentConfiguration->e2nodeComponentResponsePart.size);
4743 /*******************************************************************
4745 * @brief free e2 node component component identifier
4749 * Function : freeE2NodeComponentIdentifier
4752 * - free e2 node component component identifier
4754 * @params[in] E2nodeComponentID_t *componentID
4755 * @return ROK - success
4758 * ****************************************************************/
4760 void freeE2NodeComponentIdentifier(E2nodeComponentID_t *componentID)
4762 if(componentID->choice.e2nodeComponentInterfaceTypeF1)
4764 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
4765 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
4770 /*******************************************************************
4772 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
4776 * Function : FreeE2NodeConfigUpdate
4779 * - freeing the memory allocated for E2nodeConfigurationUpdate
4781 * @params[in] E2AP_PDU_t *e2apMsg
4782 * @return ROK - success
4785 * ****************************************************************/
4787 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
4789 uint8_t arrIdx =0, e2NodeUpdateListIdx=0, e2NodeRemovalListIdx=0, e2NodeAddListIdx=0;
4790 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate =NULL;
4791 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList =NULL;
4792 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItem =NULL;
4793 E2nodeComponentConfigRemoval_List_t *e2NodeRemovalList =NULL;
4794 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItem =NULL;
4795 E2nodeComponentConfigAddition_List_t *e2NodeAddList =NULL;
4796 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem =NULL;
4798 if(e2apMsg != NULLP)
4800 if(e2apMsg->choice.initiatingMessage != NULLP)
4802 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4803 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
4805 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
4807 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx])
4810 switch(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id)
4812 case ProtocolIE_IDE2_id_TransactionID:
4815 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
4817 e2NodeAddList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
4818 if(e2NodeAddList->list.array)
4820 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
4822 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
4824 freeE2NodeComponentConfiguration(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration);
4825 freeE2NodeComponentIdentifier(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID);
4826 DU_FREE(e2NodeAddItem, sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
4828 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
4832 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
4834 e2NodeUpdateList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List;
4835 if(e2NodeUpdateList->list.array)
4837 for(e2NodeUpdateListIdx = 0; e2NodeUpdateListIdx< e2NodeUpdateList->list.count; e2NodeUpdateListIdx++)
4839 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[e2NodeUpdateListIdx];
4841 freeE2NodeComponentConfiguration(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentConfiguration);
4842 freeE2NodeComponentIdentifier(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentID);
4843 DU_FREE(e2NodeUpdateItem, sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
4845 DU_FREE(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
4849 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
4851 e2NodeRemovalList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List;
4852 if(e2NodeRemovalList->list.array)
4854 for(e2NodeRemovalListIdx = 0; e2NodeRemovalListIdx< e2NodeRemovalList->list.count; e2NodeRemovalListIdx++)
4856 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemovalList->list.array[e2NodeRemovalListIdx];
4858 freeE2NodeComponentIdentifier(&e2NodeRemovalItem->value.choice.E2nodeComponentConfigRemoval_Item.e2nodeComponentID);
4859 DU_FREE(e2NodeRemovalItem, sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
4861 DU_FREE(e2NodeRemovalList->list.array, e2NodeRemovalList->list.size);
4869 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4872 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4874 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4876 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4880 /*******************************************************************
4882 * @brief Buld and send the E2 node config update msg
4886 * Function : BuildAndSendE2NodeConfigUpdate
4889 * - Buld and send the E2 node config update msg
4892 * @return ROK - success
4895 * ****************************************************************/
4897 uint8_t BuildAndSendE2NodeConfigUpdate(E2NodeConfigList *e2NodeList)
4899 uint8_t ret = RFAILED;
4900 uint8_t arrIdx = 0,elementCnt = 0;
4902 E2AP_PDU_t *e2apMsg = NULLP;
4903 asn_enc_rval_t encRetVal; /* Encoder return value */
4904 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
4906 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
4909 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4910 if(e2apMsg == NULLP)
4912 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4916 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4917 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4918 if(e2apMsg->choice.initiatingMessage == NULLP)
4920 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4923 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4924 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
4925 e2apMsg->choice.initiatingMessage->value.present = \
4926 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
4927 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4930 if(e2NodeList->addE2NodeCount)
4932 if(e2NodeList->updateE2NodeCount)
4934 if(e2NodeList->removeE2NodeCount)
4937 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
4938 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
4939 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4940 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
4942 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4946 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
4948 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4949 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
4952 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4957 if(arrIdx<elementCnt)
4961 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4962 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4963 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
4964 transId = assignTransactionId();
4965 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4967 if(e2NodeList->addE2NodeCount)
4970 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
4971 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4972 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigAddition_List;
4973 if(BuildE2NodeConfigAddList(&(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List),\
4974 ProcedureCodeE2_id_E2nodeConfigurationUpdate, e2NodeList->addE2NodeCount, e2NodeList->addE2Node)!=ROK)
4976 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
4981 if(e2NodeList->updateE2NodeCount)
4984 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate;
4985 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4986 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigUpdate_List;
4987 if(BuildE2NodeConfigUpdateList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List,\
4988 e2NodeList->updateE2NodeCount, e2NodeList->updateE2Node) != ROK)
4991 DU_LOG("\nERROR --> E2AP : Failed to update the E2 node configuration");
4996 if(e2NodeList->removeE2NodeCount)
4999 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval;
5000 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5001 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigRemoval_List;
5002 if(BuildE2NodeConfigRemoveList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List,\
5003 e2NodeList->removeE2NodeCount, e2NodeList->removeE2Node) != ROK)
5006 DU_LOG("\nERROR --> E2AP : Failed to remove the E2 node configuration");
5011 /* Prints the Msg formed */
5012 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5014 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5016 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5017 if(encRetVal.encoded == ENCODE_FAIL)
5019 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
5020 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5025 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
5026 #ifdef DEBUG_ASN_PRINT
5027 for(int i=0; i< encBufSize; i++)
5029 printf("%x",encBuf[i]);
5033 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
5035 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
5039 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5040 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5041 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.e2NodeConfigUpdate.configList, e2NodeList, sizeof(E2NodeConfigList));
5046 FreeE2NodeConfigUpdate(e2apMsg);
5050 /*******************************************************************
5052 * @brief Deallocate the memory allocated for E2ResetRequest msg
5056 * Function : FreeE2ResetRequest
5059 * - freeing the memory allocated for E2ResetRequest
5061 * @params[in] E2AP_PDU_t *e2apMsg
5062 * @return ROK - success
5065 * ****************************************************************/
5066 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
5069 ResetRequestE2_t *resetReq = NULLP;
5071 if(e2apMsg != NULLP)
5073 if(e2apMsg->choice.initiatingMessage != NULLP)
5075 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5076 if(resetReq->protocolIEs.list.array)
5078 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
5080 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5082 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5084 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5086 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5090 /*******************************************************************
5092 * @brief Build and send the E2 reset request msg
5096 * Function : BuildAndSendE2ResetRequest
5099 * - Buld and send the E2 reset request msg to RIC
5103 * @return ROK - success
5106 * ****************************************************************/
5107 uint8_t BuildAndSendE2ResetRequest(E2FailureCause resetCause)
5109 uint8_t ieIdx = 0, elementCnt = 0;
5110 uint16_t transId = 0;
5111 uint8_t ret = RFAILED;
5112 E2AP_PDU_t *e2apMsg = NULLP;
5113 ResetRequestE2_t *resetReq = NULLP;
5114 asn_enc_rval_t encRetVal; /* Encoder return value */
5116 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
5120 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5121 if(e2apMsg == NULLP)
5123 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
5127 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5128 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5129 if(e2apMsg->choice.initiatingMessage == NULLP)
5131 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
5135 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
5136 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5137 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
5138 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5141 resetReq->protocolIEs.list.count = elementCnt;
5142 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
5144 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5145 if(!resetReq->protocolIEs.list.array)
5147 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5148 Reset Request IE array");
5152 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5154 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5155 if(!resetReq->protocolIEs.list.array[ieIdx])
5157 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5158 Reset Request IE array element");
5163 /* In case of failure */
5164 if(ieIdx < elementCnt)
5168 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5169 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
5170 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
5171 transId = assignTransactionId();
5172 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
5175 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
5176 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
5177 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
5178 fillE2Cause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, resetCause);
5180 /* Prints the Msg formed */
5181 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5183 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5185 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
5187 if(encRetVal.encoded == ENCODE_FAIL)
5189 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
5190 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5195 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
5196 #ifdef DEBUG_ASN_PRINT
5197 for(int i=0; i< encBufSize; i++)
5199 printf("%x",encBuf[i]);
5203 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5205 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5209 /* In case the message is sent successfully, store the transaction info to
5210 * be used when response is received */
5211 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5212 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5218 /* Free all memory */
5219 FreeE2ResetRequest(e2apMsg);
5223 /*******************************************************************
5225 * @brief Deallocate the memory allocated for Reset Response msg
5229 * Function : freeAperDecodingOfE2ResetRsp
5232 * - freeing the memory allocated for Reset response
5234 * @params[in] ResetResponseE2_t *resetResponse
5237 * ****************************************************************/
5238 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
5244 if(resetResponse->protocolIEs.list.array)
5246 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5248 if(resetResponse->protocolIEs.list.array[ieIdx])
5250 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5252 case ProtocolIE_IDE2_id_TransactionID:
5255 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5258 free(resetResponse->protocolIEs.list.array[ieIdx]);
5261 free(resetResponse->protocolIEs.list.array);
5266 /******************************************************************
5268 * @brief Processes E2 Reset Response sent by RIC
5272 * Function : procResetResponse
5274 * Functionality: Processes E2 Reset Response sent by RIC
5276 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5279 * ****************************************************************/
5280 void procResetResponse(E2AP_PDU_t *e2apMsg)
5282 bool invalidTransId=false;
5284 uint16_t transId =0;
5285 uint16_t ranFuncIdx=0;
5286 ResetResponseE2_t *resetResponse =NULLP;
5288 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
5289 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
5291 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5293 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5295 case ProtocolIE_IDE2_id_TransactionID:
5297 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5298 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \
5299 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
5301 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5305 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5306 invalidTransId = true;
5310 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5312 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
5314 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
5316 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
5317 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
5324 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
5325 resetResponse->protocolIEs.list.array[ieIdx]->id);
5330 if(invalidTransId == true)
5336 freeAperDecodingOfE2ResetRsp(resetResponse);
5339 /******************************************************************
5341 * @brief Deallocation of memory allocated by aper decoder for e2 setup Failure
5345 * Function : freeAperDecodingOfE2SetupFailure
5347 * Functionality: Deallocation of memory allocated by aper decoder for e2
5350 * @params[in] E2setupFailure_t *e2SetupFailure;
5353 * ****************************************************************/
5354 void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure)
5360 if(e2SetupFailure->protocolIEs.list.array)
5362 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5364 if(e2SetupFailure->protocolIEs.list.array[arrIdx])
5366 free(e2SetupFailure->protocolIEs.list.array[arrIdx]);
5369 free(e2SetupFailure->protocolIEs.list.array);
5373 /******************************************************************
5375 * @brief Processes E2 Setup Failure sent by RIC
5379 * Function : procE2SetupFailure
5381 * Functionality: Processes E2 Setup failure sent by RIC
5383 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5384 * @return ROK - success
5387 * ****************************************************************/
5388 void procE2SetupFailure(E2AP_PDU_t *e2apMsg)
5390 uint16_t transId =0;
5391 uint8_t arrIdx =0, timerValue=0;
5392 E2setupFailure_t *e2SetupFailure;
5394 DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
5395 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
5397 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5399 switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id)
5401 case ProtocolIE_IDE2_id_TransactionID:
5403 transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5404 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
5405 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5407 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5411 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5416 case ProtocolIE_IDE2_id_TimeToWaitE2:
5418 timerValue = convertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
5419 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE)
5421 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue);
5425 DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
5433 freeAperDecodingOfE2SetupFailure(e2SetupFailure);
5435 /******************************************************************
5437 * @brief Deallocation of memory allocated by aper decoder for RIC service Query
5441 * Function : freeAperDecodingOfRicServiceQuery
5443 * Functionality: Deallocation of memory allocated by aper decoder for RIC
5446 * @params[in] RICserviceQuery_t *ricServiceQuery;
5449 * ****************************************************************/
5451 void freeAperDecodingOfRicServiceQuery(RICserviceQuery_t *ricServiceQuery)
5453 uint8_t arrIdx,ranFuncIdx;
5454 RANfunctionsID_List_t *ranFuncAddedList;
5458 if(ricServiceQuery->protocolIEs.list.array)
5460 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5462 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
5464 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5466 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5468 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5469 if(ranFuncAddedList->list.array)
5471 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5473 free(ranFuncAddedList->list.array[ranFuncIdx]);
5475 free(ranFuncAddedList->list.array);;
5482 free(ricServiceQuery->protocolIEs.list.array[arrIdx]);
5485 free(ricServiceQuery->protocolIEs.list.array);
5489 /*******************************************************************
5491 * @brief Build RanFunction Delete List
5495 * Function : BuildRanFunctionDeleteList
5497 * Functionality: Build RanFunction Delete List
5500 * RANfunctionsID List
5501 * Count of the RAN function
5502 * Received RAN function list
5504 * @return ROK - success
5507 ******************************************************************/
5509 uint8_t BuildRanFunctionDeleteList(RANfunctionsID_List_t *deleteList, uint8_t count, RanFuncInfo *recvdRanFunc)
5511 uint8_t ranFuncIdx=0;
5512 RANfunctionID_ItemIEs_t *delRanFuncItem;
5516 deleteList->list.count = count;
5517 deleteList->list.size = deleteList->list.count * sizeof(RANfunctionID_ItemIEs_t*);
5518 DU_ALLOC(deleteList->list.array, deleteList->list.size);
5519 if(deleteList->list.array == NULLP)
5521 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5524 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
5526 DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t));
5527 if(deleteList->list.array[ranFuncIdx] == NULLP)
5529 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5532 delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx];
5533 delRanFuncItem->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
5534 delRanFuncItem->criticality = CriticalityE2_ignore;
5535 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionID = recvdRanFunc[ranFuncIdx].id;
5536 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionRevision = recvdRanFunc[ranFuncIdx].revisionCounter;
5542 /*******************************************************************
5544 * @brief De Allocate Ric Service Update message
5548 * Function : FreeRicServiceUpdate
5550 * Functionality: De-Allocating Ric Service Update message
5552 * @params[in] E2AP_PDU_t *e2apMsg
5556 * ****************************************************************/
5558 void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg)
5561 uint8_t ranFuncAddListIdx=0, ranFuncDelIdx=0;
5562 RICserviceUpdate_t *ricServiceUpdate;
5563 RANfunctions_List_t *ranFunctionsList;
5564 RANfunction_ItemIEs_t *ranFuncItemIe;
5565 RANfunction_Item_t *ranFunItem;
5566 RANfunctionsID_List_t *deleteList;
5568 /* De-allocating Memory */
5569 if(e2apMsg != NULLP)
5571 if(e2apMsg->choice.initiatingMessage != NULLP)
5573 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5574 if(ricServiceUpdate->protocolIEs.list.array != NULLP)
5576 for(arrIdx = 0; arrIdx < ricServiceUpdate->protocolIEs.list.count; arrIdx++)
5578 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] != NULLP)
5580 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
5582 case ProtocolIE_IDE2_id_TransactionID:
5585 case ProtocolIE_IDE2_id_RANfunctionsAdded:
5586 case ProtocolIE_IDE2_id_RANfunctionsModified:
5588 ranFunctionsList = &(ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
5589 if(ranFunctionsList->list.array)
5591 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
5593 if(ranFunctionsList->list.array[ranFuncAddListIdx])
5595 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
5596 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
5597 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
5598 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
5599 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
5602 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
5606 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
5608 deleteList= &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5609 if(deleteList->list.array)
5611 for(ranFuncDelIdx = 0; ranFuncDelIdx< deleteList->list.count; ranFuncDelIdx++)
5613 DU_FREE(deleteList->list.array[ranFuncDelIdx], sizeof(RANfunctionID_ItemIEs_t));
5615 DU_FREE(deleteList->list.array, deleteList->list.size);
5621 DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
5622 (ricServiceUpdate->protocolIEs.list.array[arrIdx]->id));
5625 DU_FREE(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5628 DU_FREE(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5630 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5632 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5636 /*******************************************************************
5638 * @brief Builds and Send the RicServiceUpdateuest
5642 * Function : BuildAndSendRicServiceUpdate
5644 * Functionality:Fills the RicServiceUpdateuest
5646 * @return ROK - success
5649 ******************************************************************/
5651 uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate)
5653 uint16_t transId = 0;
5654 bool memAllocFailed =false;
5655 uint8_t arrIdx = 0, elementCnt=0,ret = RFAILED;
5656 E2AP_PDU_t *e2apMsg = NULLP;
5657 RICserviceUpdate_t *ricServiceUpdate = NULLP;
5658 asn_enc_rval_t encRetVal; /* Encoder return value */
5660 DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n");
5663 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5664 if(e2apMsg == NULLP)
5666 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5669 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5670 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5671 if(e2apMsg->choice.initiatingMessage == NULLP)
5673 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5676 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5677 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
5678 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceUpdate;
5679 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5681 /* For TransId IE, set elementCnt to 1.
5682 If there is any item in the RAN function add list, RAN function modification list, or RAN function delete list, increment the elementCnt.*/
5685 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5687 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5689 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5692 ricServiceUpdate->protocolIEs.list.count = elementCnt;
5693 ricServiceUpdate->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdate_IEs_t*);
5695 /* Initialize the E2Setup members */
5696 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5697 if(ricServiceUpdate->protocolIEs.list.array == NULLP)
5699 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
5703 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
5705 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5706 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP)
5708 memAllocFailed = true;
5709 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
5713 if(memAllocFailed == true)
5719 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5720 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5721 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
5722 if(serviceUpdate.dir == E2_NODE_INITIATED)
5723 transId = assignTransactionId();
5725 transId = serviceUpdate.transId;
5726 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5728 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5731 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
5732 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5733 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5734 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,\
5735 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded, serviceUpdate.recvRanFuncList.ranFunToBeAdded) !=ROK)
5741 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5744 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsModified;
5745 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5746 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5747 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,
5748 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeModified, serviceUpdate.recvRanFuncList.ranFunToBeModified) !=ROK)
5754 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5757 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsDeleted;
5758 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5759 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctionsID_List;
5760 if(BuildRanFunctionDeleteList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List,\
5761 serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted, serviceUpdate.recvRanFuncList.ranFunToBeDeleted) != ROK)
5766 /* Prints the Msg formed */
5767 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5769 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5771 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5772 if(encRetVal.encoded == ENCODE_FAIL)
5774 DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
5775 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5780 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
5781 #ifdef DEBUG_ASN_PRINT
5782 for(int i=0; i< encBufSize; i++)
5784 printf("%x",encBuf[i]);
5788 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5790 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5799 if(serviceUpdate.dir == E2_NODE_INITIATED)
5801 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5802 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5806 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId = transId;
5807 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5809 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.dir = serviceUpdate.dir;
5810 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.transId =transId;
5811 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.recvRanFuncList, &serviceUpdate.recvRanFuncList, sizeof(E2TmpRanFunList));
5813 FreeRicServiceUpdate(e2apMsg);
5816 /******************************************************************
5818 * @brief Processes RIC service Query sent by RIC
5822 * Function : procRicServiceQuery
5824 * Functionality: Processes RIC service Query sent by RIC
5826 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5827 * @return ROK - success
5830 * ****************************************************************/
5832 void procRicServiceQuery(E2AP_PDU_t *e2apMsg)
5835 uint16_t arrIdx =0, ranFuncIdx=0,tmpIdx=0;
5836 uint16_t id,revisionCcounter;
5837 bool tmpArray[MAX_RAN_FUNCTION] = {false};
5838 RICserviceQuery_t *ricServiceQuery=NULL;
5839 RicServiceUpdate ricUpdate;
5840 RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
5841 RANfunctionsID_List_t *ranFuncAddedList;
5843 DU_LOG("\nINFO --> E2AP : RIC Service Query received");
5844 memset(&ricUpdate, 0, sizeof(RicServiceUpdate));
5845 ricUpdate.dir = RIC_INITIATED;
5846 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
5848 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5850 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5852 /* TODO completing in next patch/gerrit */
5853 case ProtocolIE_IDE2_id_TransactionID:
5855 ricUpdate.transId = ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5859 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5861 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5862 if(ranFuncAddedList->list.array)
5864 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5866 if(ranFuncAddedList->list.array[ranFuncIdx])
5868 /* Using the RAN function Id, identify the RAN function to be modified or deleted. */
5870 ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
5871 id = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID;
5872 revisionCcounter = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision;
5874 if((id != duCb.e2apDb.ranFunction[id-1].id))
5876 action = CONFIG_DEL;
5878 else if((id == duCb.e2apDb.ranFunction[id-1].id)&&(revisionCcounter!=duCb.e2apDb.ranFunction[id-1].revisionCounter))
5880 action = CONFIG_MOD;
5883 if(action == CONFIG_DEL)
5885 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].id = id;
5886 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].revisionCounter = revisionCcounter;
5887 ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted++;
5889 else if(action == CONFIG_MOD)
5891 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].id = id;
5892 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].revisionCounter = revisionCcounter;
5893 ricUpdate.recvRanFuncList.numOfRanFunToBeModified++;
5896 /* If any ID is set to true, it means that the ID has been used in either modification or deletion list.
5897 * Else we will add the IDs into the added list */
5898 tmpArray[id-1] = true;
5907 /* Traversing the whole RAN function list in ducb to check if any new Ran function ids have been added. */
5908 for(arrIdx =0; arrIdx<MAX_RAN_FUNCTION; arrIdx++)
5910 tmpIdx= ricUpdate.recvRanFuncList.numOfRanFunToBeAdded;
5911 if((duCb.e2apDb.ranFunction[arrIdx].id >0)&&(!tmpArray[arrIdx]))
5913 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[arrIdx].id;
5914 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[arrIdx].revisionCounter;
5915 ricUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
5919 if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK)
5921 DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message");
5924 freeAperDecodingOfRicServiceQuery(ricServiceQuery);
5927 /******************************************************************
5929 * @brief Deallocation of memory allocated by aper decoder for
5930 * RIC service update ack
5934 * Function : freeAperDecodingOfRicServiceUpdateAck
5936 * Functionality: Deallocation of memory allocated by aper decoder
5937 * for RIC service update ack
5939 * @params[in] RICserviceUpdateAck_t *ricServiceAck;
5942 * ****************************************************************/
5944 void freeAperDecodingOfRicServiceUpdateAck(RICserviceUpdateAcknowledge_t *ricServiceAck)
5946 uint8_t arrIdx=0,ranFuncIdx=0;
5947 RANfunctionsID_List_t *ranFuncAddedList=NULL;
5951 if(ricServiceAck->protocolIEs.list.array)
5953 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5955 if(ricServiceAck->protocolIEs.list.array[arrIdx])
5957 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5959 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5961 ranFuncAddedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5962 if(ranFuncAddedList->list.array)
5964 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5966 free(ranFuncAddedList->list.array[ranFuncIdx]);
5968 free(ranFuncAddedList->list.array);
5975 free(ricServiceAck->protocolIEs.list.array[arrIdx]);
5978 free(ricServiceAck->protocolIEs.list.array);
5983 /******************************************************************
5985 * @brief Processes RIC service update ack sent by RIC
5989 * Function : procRicServiceUpdateAck
5991 * Functionality: Processes RIC service update ack sent by RIC
5993 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5994 * @return ROK - success
5997 * ****************************************************************/
5999 void procRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
6002 uint16_t transId =0;
6003 uint16_t id =0, tmpIdx=0, ranFuncIdx=0;
6004 RicServiceUpdate serviceUpdate;
6005 RANfunctionsIDcause_List_t *rejectedList=NULL;
6006 RICserviceUpdateAcknowledge_t *ricServiceAck=NULL;
6007 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
6009 DU_LOG("\nINFO --> E2AP : RIC service update ack received");
6010 memset(&serviceUpdate, 0, sizeof(RicServiceUpdate));
6011 ricServiceAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
6013 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
6015 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
6017 case ProtocolIE_IDE2_id_TransactionID:
6019 transId = ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
6020 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
6021 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
6023 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
6025 else if((duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId == transId) &&\
6026 (duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
6028 memset(&duCb.e2apDb.e2TransInfo.ricInitTransaction[transId], 0, sizeof(E2TransInfo));
6032 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
6038 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
6041 case ProtocolIE_IDE2_id_RANfunctionsRejected:
6043 rejectedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
6044 if(rejectedList->list.array)
6046 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
6048 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)rejectedList->list.array[ranFuncIdx];
6049 id = ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID;
6050 tmpIdx= serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded;
6051 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[id-1].id;
6052 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[id-1].revisionCounter;
6053 serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
6062 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
6064 serviceUpdate.dir = E2_NODE_INITIATED;
6065 BuildAndSendRicServiceUpdate(serviceUpdate);
6067 freeAperDecodingOfRicServiceUpdateAck(ricServiceAck);
6070 /******************************************************************
6072 * @brief Deallocation of memory allocated by aper decoder for
6073 * RIC service update failure
6077 * Function : freeAperDecodingOfRicServiceUpdateFailure
6079 * Functionality: Deallocation of memory allocated by aper decoder
6080 * for RIC service update failure
6082 * @params[in] RICserviceUpdateFailure_t *ricServiceFailure;
6085 * ****************************************************************/
6087 void freeAperDecodingOfRicServiceUpdateFailure(RICserviceUpdateFailure_t *ricServiceFailure)
6091 if(ricServiceFailure)
6093 if(ricServiceFailure->protocolIEs.list.array)
6095 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6097 if(ricServiceFailure->protocolIEs.list.array[arrIdx])
6099 free(ricServiceFailure->protocolIEs.list.array[arrIdx]);
6102 free(ricServiceFailure->protocolIEs.list.array);
6107 /******************************************************************
6109 * @brief Processes RIC service update failure sent by RIC
6113 * Function : procRicServiceUpdateFailure
6115 * Functionality: Processes RIC service update failure sent by RIC
6117 * @params[in] E2AP_PDU_t ASN decoded E2AP message
6118 * @return ROK - success
6121 * ****************************************************************/
6123 void procRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
6125 uint8_t arrIdx =0, timerValue=0;
6126 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
6128 DU_LOG("\nINFO --> E2AP : RIC service update failure received");
6129 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
6131 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6133 switch(ricServiceFailure->protocolIEs.list.array[arrIdx]->id)
6135 case ProtocolIE_IDE2_id_TransactionID:
6139 case ProtocolIE_IDE2_id_TimeToWaitE2:
6141 timerValue = convertE2WaitTimerEnumToValue(ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
6142 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR)) == FALSE)
6144 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR, timerValue);
6148 DU_LOG("\nERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running");
6153 case ProtocolIE_IDE2_id_CauseE2:
6160 freeAperDecodingOfRicServiceUpdateFailure(ricServiceFailure);
6163 /******************************************************************
6165 * @brief DU Send E2 Node Configuration Update
6169 * Function : duSendE2NodeConfigurationUpdate
6171 * Functionality: DU Send E2 Node Configuration Update
6173 * @return ROK - success
6176 * ****************************************************************/
6178 uint8_t duSendE2NodeConfigurationUpdate()
6180 E2NodeConfigList e2NodeList;
6181 CmLList *node =NULL;
6182 E2NodeComponent *e2NodeComponentInfo=NULL;
6184 memset(&e2NodeList, 0, sizeof(E2NodeConfigList));
6185 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
6188 e2NodeComponentInfo = (E2NodeComponent*)node->node;
6190 if(e2NodeComponentInfo->addConfiguration)
6192 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6193 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6194 e2NodeList.addE2NodeCount++;
6197 if(e2NodeComponentInfo->updateConfiguration)
6199 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6200 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6201 e2NodeList.updateE2NodeCount++;
6204 if(e2NodeComponentInfo->deleteConfiguration == true)
6206 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6207 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].componentId = e2NodeComponentInfo->componentId;
6208 e2NodeList.removeE2NodeCount++;
6214 if(BuildAndSendE2NodeConfigUpdate(&e2NodeList) !=ROK)
6216 DU_LOG("\nERROR --> E2AP : Failed to build and send e2 node config update message to RIC_stub");
6222 /*******************************************************************
6224 * @brief Free RIC Subscription Modification Required
6228 * Function : FreeRicSubsModRequired
6230 * Functionality: Freqq RIC Subscription Modification required
6232 * @param E2AP Message PDU to be freed
6235 ******************************************************************/
6236 void FreeRicSubsModRequired(E2AP_PDU_t *e2apMsg)
6238 uint8_t ieIdx = 0, arrIdx = 0;
6239 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6240 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6241 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6242 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6246 if(e2apMsg->choice.initiatingMessage)
6248 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6249 if(ricSubsModReqd->protocolIEs.list.array)
6251 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
6253 if(ricSubsModReqd->protocolIEs.list.array[ieIdx])
6255 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6256 switch(ricSubsModReqdIe->id)
6258 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
6260 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6261 if(actionToBeModList->list.array)
6263 for(arrIdx = 0; arrIdx < actionToBeModList->list.count; arrIdx++)
6265 DU_FREE(actionToBeModList->list.array[arrIdx], \
6266 sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6268 DU_FREE(actionToBeModList->list.array, actionToBeModList->list.size);
6273 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
6275 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6276 if(actionToBeRmvList->list.array)
6278 for(arrIdx = 0; arrIdx < actionToBeRmvList->list.count; arrIdx++)
6280 DU_FREE(actionToBeRmvList->list.array[arrIdx], \
6281 sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6283 DU_FREE(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6291 DU_FREE(ricSubsModReqd->protocolIEs.list.array[ieIdx], \
6292 sizeof(RICsubscriptionModificationRequired_IEs_t));
6295 DU_FREE(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6297 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6299 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6303 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6304 * However, E2SM-KPM supports only RIC Report service.
6305 * Hence there is no subsequent action in RIC subscription that may require modification.
6306 * So commenting the action-modification IEs for the time being
6309 /*******************************************************************
6311 * @brief Fill Action required to be modified list
6315 * Function : FillActionReqdToBeModList
6317 * Functionality: Fill Action required to be modified list
6319 * @param RIC Actions Required To Be Modified List to be filled
6320 * Number of actions to be modified
6321 * RIC Subscription DB
6322 * @return ROK - success
6325 ******************************************************************/
6326 uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod,\
6327 RicSubscription *ricSubscription)
6330 CmLList *actionNode = NULLP;
6331 ActionInfo *actionDb = NULLP;
6332 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL;
6334 actionToBeModList->list.count = numActionsMod;
6335 actionToBeModList->list.size = numActionsMod * sizeof(RICaction_RequiredToBeModified_ItemIEs_t *);
6336 DU_ALLOC(actionToBeModList->list.array, actionToBeModList->list.size);
6337 if(!actionToBeModList->list.array)
6339 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6344 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6347 actionDb = (ActionInfo*)(actionNode->node);
6348 if(actionDb->action == CONFIG_MOD)
6350 DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6351 if(!actionToBeModList->list.array[arrIdx])
6353 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6356 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[arrIdx];
6358 actionToBeMod->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeModified_Item;
6359 actionToBeMod->criticality = CriticalityE2_reject;
6360 actionToBeMod->value.present = \
6361 RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item;
6362 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \
6364 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms;
6373 /*******************************************************************
6375 * @brief Fill Action required to be removed list
6379 * Function : FillActionReqdToBeRmvList
6381 * Functionality: Fill Action required to be removed list
6383 * @param RIC Actions Required To Be Removed List to be filled
6384 * Number of actions to be removed
6385 * RIC Subscription DB
6386 * @return ROK - success
6389 ******************************************************************/
6390 uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \
6391 RicSubscription *ricSubscription)
6394 CmLList *actionNode = NULLP;
6395 ActionInfo *actionDb = NULLP;
6396 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL;
6398 actionToBeRmvList->list.count = numActionsRmv;
6399 actionToBeRmvList->list.size = numActionsRmv * sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t *);
6400 DU_ALLOC(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6401 if(!actionToBeRmvList->list.array)
6403 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6408 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6411 actionDb = (ActionInfo*)(actionNode->node);
6412 if(actionDb->action == CONFIG_DEL)
6414 DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6415 if(!actionToBeRmvList->list.array[arrIdx])
6417 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6420 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[arrIdx];
6422 actionToBeRmv->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeRemoved_Item;
6423 actionToBeRmv->criticality = CriticalityE2_reject;
6424 actionToBeRmv->value.present = \
6425 RICaction_RequiredToBeRemoved_ItemIEs__value_PR_RICaction_RequiredToBeRemoved_Item;
6426 actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = actionDb->actionId;
6427 fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, actionDb->failureCause);
6435 /*******************************************************************
6437 * @brief Fill RIC Subscription Modification Required IEs
6441 * Function : FillRicSubsModRequired
6443 * Functionality: Fill RIC Subscription Modification Required IEs
6445 * @param RIC Subscription Modification Required IEs to be filled
6446 * RIC Subscription DB
6447 * @return ROK - success
6450 ******************************************************************/
6451 uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription)
6453 ActionInfo * actionDb=NULLP;
6454 CmLList *actionNode = NULLP;
6455 uint8_t ieIdx = 0, elementCnt=0;
6456 uint8_t numActionsMod = 0, numActionsRmv = 0;
6457 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6458 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6460 /* Unused in case of E2SM-KPM */
6462 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6465 /* Count number of Actions to be modified or deleted */
6466 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6469 actionDb = (ActionInfo*)(actionNode->node);
6470 if(actionDb->action == CONFIG_MOD)
6472 else if(actionDb->action == CONFIG_DEL)
6474 actionNode = actionNode->next;
6477 /* Count number of IEs to be added to messages */
6484 ricSubsModReqd->protocolIEs.list.count = elementCnt;
6485 ricSubsModReqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequired_IEs_t *);
6486 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6487 if(!ricSubsModReqd->protocolIEs.list.array)
6489 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6493 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
6495 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRequired_IEs_t));
6496 if(!ricSubsModReqd->protocolIEs.list.array[ieIdx])
6498 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6503 /* RIC Request ID */
6505 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6506 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICrequestID;
6507 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6508 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RICrequestID;
6509 ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID = ricSubscription->requestId.requestorId;
6510 ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID = ricSubscription->requestId.instanceId;
6512 /* RAN Function ID */
6514 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6515 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RANfunctionID;
6516 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6517 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RANfunctionID;
6518 ricSubsModReqdIe->value.choice.RANfunctionID = ricSubscription->ranFuncId;
6520 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6521 * However, E2SM-KPM supports only RIC Report service.
6522 * Hence there is no subsequent action in RIC subscription that may require modification.
6523 * So commenting the action-modification IEs for the time being
6526 /* RIC Actions Required to be Modified */
6530 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6531 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List;
6532 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6533 ricSubsModReqdIe->value.present = \
6534 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeModified_List;
6535 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6537 if(FillActionReqdToBeModList(actionToBeModList, numActionsMod, ricSubscription) != ROK)
6539 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__);
6545 /* RIC Actions Required to be removed */
6549 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6550 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List;
6551 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6552 ricSubsModReqdIe->value.present = \
6553 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeRemoved_List;
6554 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6556 if(FillActionReqdToBeRmvList(actionToBeRmvList, numActionsRmv, ricSubscription) != ROK)
6558 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__);
6566 /*******************************************************************
6568 * @brief Builds and Send RIC Subscription Modification Required
6573 * Function : BuildAndSendRicSubsModRequired
6575 * Functionality: Builds and Send RIC Subscription Modification
6578 * @param RIC Subscription DB
6579 * @return ROK - success
6582 ******************************************************************/
6583 uint8_t BuildAndSendRicSubsModRequired(RicSubscription *ricSubscription)
6585 uint8_t ret = RFAILED;
6586 E2AP_PDU_t *e2apMsg = NULLP;
6587 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6588 asn_enc_rval_t encRetVal; /* Encoder return value */
6590 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Required \n");
6593 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6594 if(e2apMsg == NULLP)
6596 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6600 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6601 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6602 if(e2apMsg->choice.initiatingMessage == NULLP)
6604 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6607 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6608 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
6609 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired;
6611 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6613 if(FillRicSubsModRequired(ricSubsModReqd, ricSubscription) != ROK)
6615 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__);
6620 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6622 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6624 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6625 if(encRetVal.encoded == ENCODE_FAIL)
6627 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modifiction Required structure (at %s)\n",\
6628 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6633 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Required \n");
6634 #ifdef DEBUG_ASN_PRINT
6635 for(int i=0; i< encBufSize; i++)
6637 printf("%x",encBuf[i]);
6641 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
6643 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Modification Required failed");
6650 /* Free RIC Subscription modification required */
6651 FreeRicSubsModRequired(e2apMsg);
6655 /*******************************************************************
6657 * @brief Free APER decoding of RIC Subscription Modification Confirm
6661 * Function : freeAperDecodingOfRicSubsModConfirm
6663 * Functionality: Free APER decoding of RIC Subscription
6664 * Modification Confirm
6666 * @param E2AP Message PDU
6669 ******************************************************************/
6670 void freeAperDecodingOfRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
6672 uint8_t ieIdx = 0, arrIdx=0;
6673 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6674 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6675 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6676 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6677 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6678 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6680 if(e2apMsg && e2apMsg->choice.successfulOutcome)
6682 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6683 if(ricSubsModCfm->protocolIEs.list.array)
6685 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6687 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
6689 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6690 switch(ricSubsModCfmIe->id)
6692 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6694 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6695 if(modCfmList->list.array)
6697 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6699 if(modCfmList->list.array[arrIdx])
6700 free(modCfmList->list.array[arrIdx]);
6702 free(modCfmList->list.array);
6707 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6709 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6710 if(modRefusedList->list.array)
6712 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6714 if(modRefusedList->list.array[arrIdx])
6715 free(modRefusedList->list.array[arrIdx]);
6717 free(modRefusedList->list.array);
6722 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6724 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6725 if(rmvCfmList->list.array)
6727 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6729 if(rmvCfmList->list.array[arrIdx])
6730 free(rmvCfmList->list.array[arrIdx]);
6732 free(rmvCfmList->list.array);
6737 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6739 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6740 if(rmvFailList->list.array)
6742 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6744 if(rmvFailList->list.array[arrIdx])
6745 free(rmvFailList->list.array[arrIdx]);
6747 free(rmvFailList->list.array);
6756 free(ricSubsModCfmIe);
6759 free(ricSubsModCfm->protocolIEs.list.array);
6764 /*******************************************************************
6766 * @brief Process RIC Subscription Modification Confirm Message
6770 * Function : procRicSubscriptionModificationConfirm
6772 * Functionality: Process RIC Subscription Modification Confirm
6773 * Message received from RIC.
6775 * @param E2AP Message PDU
6778 ******************************************************************/
6779 void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg)
6781 uint8_t actionId = 0, ieIdx = 0, arrIdx = 0;
6782 uint16_t ranFuncId = 0;
6783 bool procFailure = false;
6784 RicRequestId ricReqId;
6785 RanFunction *ranFuncDb = NULLP;
6786 CmLList *ricSubsNode = NULLP;
6787 CmLList *actionNode= NULLP;
6788 RicSubscription *ricSubsDb = NULLP;
6789 ActionInfo *actionDb = NULLP;
6791 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6792 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6794 /* Not used in case of E2SM-KPM */
6796 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6797 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
6799 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6800 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
6803 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6804 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
6806 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6807 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
6809 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Confirm", __func__);
6814 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
6818 if(!e2apMsg->choice.successfulOutcome)
6820 DU_LOG("\nERROR --> E2AP : %s: Successful Outcome in E2AP message is NULL", __func__);
6824 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6825 if(!ricSubsModCfm->protocolIEs.list.array)
6827 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
6831 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6833 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
6835 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
6839 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6840 switch(ricSubsModCfmIe->id)
6842 case ProtocolIE_IDE2_id_RICrequestID:
6844 memset(&ricReqId, 0, sizeof(RicRequestId));
6845 ricReqId.requestorId = ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID;
6846 ricReqId.instanceId = ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID;
6850 case ProtocolIE_IDE2_id_RANfunctionID:
6852 ranFuncId = ricSubsModCfmIe->value.choice.RANfunctionID;
6853 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
6856 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
6861 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
6864 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
6865 __func__, ricReqId.requestorId, ricReqId.instanceId);
6873 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6874 * However, E2SM-KPM supports only RIC Report service.
6875 * Hence there is no subsequent action in RIC subscription that may require modification.
6876 * So commenting the action-modification IEs for the time being
6879 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6881 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6882 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6884 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
6885 actionId = modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID;
6887 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6890 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6894 actionDb->action = CONFIG_UNKNOWN;
6895 /* Further handling can be added here in future once the
6896 * use case of this procedure is identified */
6903 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6905 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6906 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6908 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
6909 actionId = modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID;
6910 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6913 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6917 /* Spec doesnt mention if in case of failure, DU should retry for modify action
6918 * Hence, chaging the action from CONFIG_MOD to CONFIG_UNKNOWN
6920 actionDb->action = CONFIG_UNKNOWN;
6928 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6930 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6931 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6933 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
6934 actionId = rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID;
6935 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6938 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6942 cmLListDelFrm(&ricSubsDb->actionSequence, actionNode);
6943 deleteActionSequence(actionNode);
6945 /* Further handling can include :
6946 * Deletion of this action from all DU layers
6954 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6956 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6957 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6959 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
6960 actionId = rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID;
6961 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6964 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6968 actionDb->action = CONFIG_UNKNOWN;
6977 } /* End of switch for Protocol IE Id */
6981 } /* End of for loop for Protocol IE list */
6986 freeAperDecodingOfRicSubsModConfirm(e2apMsg);
6990 /******************************************************************
6991 * @brief Deallocate the memory allocated for E2 Reset Response
6995 * Function : FreeE2ResetResponse
6998 * - freeing the memory allocated for E2ResetResponse
7000 * @params[in] E2AP_PDU_t *e2apMsg
7001 * @return ROK - success
7004 * ****************************************************************/
7005 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
7008 ResetResponseE2_t *resetResponse;
7010 if(e2apMsg != NULLP)
7012 if(e2apMsg->choice.successfulOutcome != NULLP)
7014 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
7015 if(resetResponse->protocolIEs.list.array)
7017 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
7019 if(resetResponse->protocolIEs.list.array[ieIdx])
7021 DU_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
7024 DU_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
7027 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7029 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
7033 /*******************************************************************
7035 * @brief Buld and send the E2 Reset Response msg
7039 * Function : BuildAndSendE2ResetResponse
7042 * - Buld and send the E2 Reset Response Message
7044 * @params[in] Trans Id
7045 * @return ROK - success
7048 * ****************************************************************/
7049 uint8_t BuildAndSendResetResponse(uint16_t transId)
7051 uint8_t ieIdx = 0, elementCnt = 0;
7052 uint8_t ret = RFAILED;
7053 E2AP_PDU_t *e2apMsg = NULLP;
7054 ResetResponseE2_t *resetResponse;
7055 asn_enc_rval_t encRetVal; /* Encoder return value */
7057 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
7060 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7061 if(e2apMsg == NULLP)
7063 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
7066 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7068 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7069 if(e2apMsg->choice.successfulOutcome == NULLP)
7071 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
7075 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
7076 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7077 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
7078 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
7081 resetResponse->protocolIEs.list.count = elementCnt;
7082 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
7083 DU_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
7084 if(!resetResponse->protocolIEs.list.array)
7086 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
7090 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
7092 DU_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
7093 if(!resetResponse->protocolIEs.list.array[ieIdx])
7095 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
7099 if(ieIdx < elementCnt)
7103 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
7104 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
7105 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
7106 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
7108 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7110 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7112 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7113 if(encRetVal.encoded == ENCODE_FAIL)
7115 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
7116 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7121 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
7122 for(int i=0; i< encBufSize; i++)
7124 DU_LOG("%x",encBuf[i]);
7129 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7131 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
7139 FreeE2ResetResponse(e2apMsg);
7143 /******************************************************************
7145 * @brief Deallocation of memory allocated by aper decoder for reset req
7149 * Function : freeAperDecodingOfE2ResetReq
7151 * Functionality: Deallocation of memory allocated by aper decoder for
7154 * @params[in] Pointer to resetReq
7157 * ****************************************************************/
7158 void freeAperDecodingOfE2ResetReq(ResetRequestE2_t *resetReq)
7164 if(resetReq->protocolIEs.list.array)
7166 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7168 if(resetReq->protocolIEs.list.array[arrIdx])
7170 free(resetReq->protocolIEs.list.array[arrIdx]);
7173 free(resetReq->protocolIEs.list.array);
7178 /*******************************************************************
7180 * @brief Process reset req received from RIC
7184 * Function : procE2ResetRequest
7186 * Functionality: Process reset req received from RIC
7188 * @param E2AP_PDU_t *e2apMsg
7191 ******************************************************************/
7193 void procE2ResetRequest(E2AP_PDU_t *e2apMsg)
7196 uint16_t transId =0;
7197 uint16_t ranFuncIdx=0;
7198 ResetRequestE2_t *resetReq;
7200 DU_LOG("\nINFO --> E2AP : E2 Reset request received");
7201 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
7203 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7205 switch(resetReq->protocolIEs.list.array[arrIdx]->id)
7207 case ProtocolIE_IDE2_id_TransactionID:
7209 transId = resetReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
7213 case ProtocolIE_IDE2_id_CauseE2:
7215 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
7217 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
7219 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
7220 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
7227 if(BuildAndSendResetResponse(transId) != ROK)
7229 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
7231 freeAperDecodingOfE2ResetReq(resetReq);
7234 /*******************************************************************
7236 * @brief Free APER decoding of RIC Subscription Modification Refuse
7240 * Function : freeAperDecodingOfRicSubsModRefuse
7242 * Functionality: Free APER decoding of RIC Subscription
7243 * Modification Refuse
7245 * @param E2AP Message PDU
7248 ******************************************************************/
7249 void freeAperDecodingOfRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
7252 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7254 if(e2apMsg && e2apMsg->choice.unsuccessfulOutcome)
7256 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7257 if(ricSubsModRefuse->protocolIEs.list.array)
7259 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7261 if(ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7262 free(ricSubsModRefuse->protocolIEs.list.array[ieIdx]);
7264 free(ricSubsModRefuse->protocolIEs.list.array);
7269 /*******************************************************************
7271 * @brief Process RIC Subscription Modification Refuse Message
7275 * Function : procRicSubscriptionModificationRefuse
7277 * Functionality: Process RIC Subscription Modification Refuse
7278 * Message received from RIC.
7280 * @param E2AP Message PDU
7283 ******************************************************************/
7284 void procRicSubscriptionModificationRefuse(E2AP_PDU_t *e2apMsg)
7287 uint16_t ranFuncId = 0;
7288 RicRequestId ricReqId;
7289 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7290 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
7291 CauseE2_t *cause = NULLP;
7293 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Refuse", __func__);
7298 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
7302 if(!e2apMsg->choice.unsuccessfulOutcome)
7304 DU_LOG("\nERROR --> E2AP : %s: Unsuccessful Outcome in E2AP message is NULL", __func__);
7308 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7309 if(!ricSubsModRefuse->protocolIEs.list.array)
7311 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
7315 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7317 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7319 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
7323 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
7324 switch(ricSubsModRefuseIe->id)
7326 case ProtocolIE_IDE2_id_RICrequestID:
7328 memset(&ricReqId, 0, sizeof(RicRequestId));
7329 ricReqId.requestorId = ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID;
7330 ricReqId.instanceId = ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID;
7334 case ProtocolIE_IDE2_id_RANfunctionID:
7336 ranFuncId = ricSubsModRefuseIe->value.choice.RANfunctionID;
7340 case ProtocolIE_IDE2_id_CauseE2:
7342 DU_LOG("\nDEBUG --> E2AP : %s: RIC subscriptiom modification refused for RIC_Requestor_ID [%d] \
7343 RIC_Instance_ID [%d] RAN_Function_ID [%d] ", __func__, ricReqId.requestorId, \
7344 ricReqId.instanceId, ranFuncId);
7346 cause = &ricSubsModRefuseIe->value.choice.CauseE2;
7347 printE2ErrorCause(cause);
7352 } /* End of switch for Protocol IE Id */
7353 } /* End of for loop for Protocol IE list */
7358 freeAperDecodingOfRicSubsModRefuse(e2apMsg);
7362 /*******************************************************************
7364 * @brief Free RIC Subscription Delete Required Message
7368 * Function : FreeRicSubscriptionDeleteRequired
7370 * Functionality: Free RIC Subscription Delete Required
7372 * @param E2AP Message PDU
7375 ******************************************************************/
7376 void FreeRicSubscriptionDeleteRequired(E2AP_PDU_t *e2apMsg, CmLListCp *ricSubsToBeDelList)
7378 uint8_t ieIdx = 0, arrIdx = 0;
7379 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7380 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7381 RICsubscription_List_withCause_t *ricSubsList = NULLP;
7382 CmLList *subsNode = NULLP;
7386 if(e2apMsg->choice.initiatingMessage)
7388 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7389 if(ricSubsDelRqd->protocolIEs.list.array)
7391 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
7393 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx])
7395 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7396 switch(ricSubsDelRqdIe->id)
7398 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
7400 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
7401 if(ricSubsList->list.array)
7403 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
7405 DU_FREE(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7407 DU_FREE(ricSubsList->list.array, ricSubsList->list.size);
7412 DU_FREE(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7415 DU_FREE(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7417 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7419 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7422 if(ricSubsToBeDelList)
7424 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7427 cmLListDelFrm(ricSubsToBeDelList, subsNode);
7428 DU_FREE(subsNode, sizeof(CmLList));
7429 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7434 /*******************************************************************
7436 * @brief Fill list of RIC subscriptions required to be deleted
7437 * with the cause of deletion
7441 * Function : fillRicSubsListWithCause
7443 * Functionality: Fill list of RIC subscriptions required to be
7444 * deleted with the cause of deletion
7446 * @param E2AP Message PDU
7449 ******************************************************************/
7450 uint8_t fillRicSubsListWithCause(RICsubscription_List_withCause_t *ricSubsList, CmLListCp ricSubsToBeDelList)
7453 CmLList *subsNode = NULLP;
7454 RicSubscription *subsInfo = NULLP;
7455 RICsubscription_withCause_ItemIEs_t *subsItemIe = NULLP;
7456 RICsubscription_withCause_Item_t *subsItem = NULLP;
7458 ricSubsList->list.count = ricSubsToBeDelList.count;
7459 ricSubsList->list.size = ricSubsList->list.count * sizeof(RICsubscription_withCause_ItemIEs_t *);
7460 DU_ALLOC(ricSubsList->list.array, ricSubsList->list.size);
7461 if(!ricSubsList->list.array)
7463 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7467 CM_LLIST_FIRST_NODE(&ricSubsToBeDelList, subsNode);
7468 while(subsNode && (ieIdx < ricSubsList->list.count))
7470 subsInfo = (RicSubscription *)subsNode->node;
7471 DU_ALLOC(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7472 if(!ricSubsList->list.array[ieIdx])
7474 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7478 subsItemIe = (RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[ieIdx];
7479 subsItemIe->id = ProtocolIE_IDE2_id_RICsubscription_withCause_Item;
7480 subsItemIe->criticality = CriticalityE2_ignore;
7481 subsItemIe->value.present = RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item;
7483 subsItem = & subsItemIe->value.choice.RICsubscription_withCause_Item;
7484 subsItem->ricRequestID.ricRequestorID = subsInfo->requestId.requestorId;
7485 subsItem->ricRequestID.ricInstanceID = subsInfo->requestId.instanceId;
7486 subsItem->ranFunctionID = subsInfo->ranFuncId;
7487 fillE2Cause(&subsItem->cause, subsInfo->failureCause);
7490 subsNode = subsNode->next;
7496 /*******************************************************************
7498 * @brief Builds and Send RIC Subscription delete required
7502 * Function : BuildAndSendRicSubscriptionDeleteRequired
7504 * Functionality: Build and send RIC subscription delete required.
7505 * There can be 2 approaches to trigger following. One of these
7506 * approaches may/may not be implemented in future:
7507 * 1. It can be triggerred immediately when a RIC subscription's
7508 * End Time has expired. In this case, only this subscription's
7509 * info will be sent in this message.
7510 * Since we have not yet added support to execute RIC
7511 * Subscription based on Start Time and End Timer, this message is
7512 * not triggered anywhere from DU APP yet.
7513 * 2. Another approach is to have a periodic timer to check subscription
7514 * status running in background.
7515 * When RIC Subscription End Time expires, this subscription is
7516 * marked to be deleted. Later when this background timer expires,
7517 * a RIC Subscription delete required is sent with all the
7518 * subscription's info which is marked to be deleted.
7519 * The following function is implemented keeping in mind the second
7523 * @return ROK - success
7526 ******************************************************************/
7527 uint8_t BuildAndSendRicSubscriptionDeleteRequired()
7529 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7530 E2AP_PDU_t *e2apMsg = NULLP;
7531 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7532 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7533 asn_enc_rval_t encRetVal; /* Encoder return value */
7534 CmLListCp ricSubsToBeDelList;
7538 /* Check if there are any RIC subscriptions to be deleted */
7539 cmLListInit(&ricSubsToBeDelList);
7540 fetchRicSubsToBeDeleted(&ricSubsToBeDelList);
7541 if(ricSubsToBeDelList.count == 0)
7543 DU_LOG("\nDEBUG --> E2AP : %s: No RIC subscriptions are required to be deleted", __func__);
7547 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Required Message\n");
7549 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7550 if(e2apMsg == NULLP)
7552 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7556 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
7557 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7558 if(e2apMsg->choice.initiatingMessage == NULLP)
7560 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7563 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDeleteRequired;
7564 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
7565 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired;
7567 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7570 ricSubsDelRqd->protocolIEs.list.count = elementCnt;
7571 ricSubsDelRqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequired_IEs_t *);
7573 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7574 if(ricSubsDelRqd->protocolIEs.list.array == NULLP)
7576 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7580 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7582 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7583 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx] == NULLP)
7585 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7586 __func__, ieIdx, __LINE__);
7590 if(ieIdx < elementCnt)
7594 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7595 ricSubsDelRqdIe->id = ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved;
7596 ricSubsDelRqdIe->criticality = CriticalityE2_ignore;
7597 ricSubsDelRqdIe->value.present = RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause;
7598 if(fillRicSubsListWithCause(&ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause, ricSubsToBeDelList)\
7601 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription list with cause", __func__);
7605 /* Prints the Msg formed */
7606 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7607 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7609 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7610 if(encRetVal.encoded == ENCODE_FAIL)
7612 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Required Message (at %s)\n",\
7613 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7618 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Required Message \n");
7619 #ifdef DEBUG_ASN_PRINT
7620 for(int i=0; i< encBufSize; i++)
7622 printf("%x",encBuf[i]);
7627 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7629 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Required Message");
7636 FreeRicSubscriptionDeleteRequired(e2apMsg, &ricSubsToBeDelList);
7640 /*******************************************************************
7642 * @brief Free RIC Subscription Delete Failure Message
7646 * Function : FreeRicSubscriptionDeleteFailure
7648 * Functionality: Free RIC Subscription Delete Failure
7650 * @param E2AP Message PDU
7653 ******************************************************************/
7654 void FreeRicSubscriptionDeleteFailure(E2AP_PDU_t *e2apMsg)
7657 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7661 if(e2apMsg->choice.unsuccessfulOutcome)
7663 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7664 if(ricSubsDelFailure->protocolIEs.list.array)
7666 for(ieIdx = 0; ieIdx < ricSubsDelFailure->protocolIEs.list.count; ieIdx++)
7668 DU_FREE(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7670 DU_FREE(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7672 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7674 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7678 /*******************************************************************
7680 * @brief Builds and Send RIC Subscription Delete Failure
7684 * Function : BuildAndSendRicSubscriptionDeleteFailure
7686 * Functionality: Build and send RIC Subscription Delete Failure.
7692 * @return ROK - success
7695 ******************************************************************/
7696 uint8_t BuildAndSendRicSubscriptionDeleteFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
7698 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7699 E2AP_PDU_t *e2apMsg = NULLP;
7700 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7701 RICsubscriptionDeleteFailure_IEs_t *ricSubsDelFailureIe = NULLP;
7702 asn_enc_rval_t encRetVal; /* Encoder return value */
7706 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Failure Message\n");
7708 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7709 if(e2apMsg == NULLP)
7711 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7715 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
7716 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7717 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
7719 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7722 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7723 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
7724 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteFailure;
7727 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7730 ricSubsDelFailure->protocolIEs.list.count = elementCnt;
7731 ricSubsDelFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteFailure_IEs_t *);
7733 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7734 if(ricSubsDelFailure->protocolIEs.list.array == NULLP)
7736 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7740 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7742 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7743 if(ricSubsDelFailure->protocolIEs.list.array[ieIdx] == NULLP)
7745 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7746 __func__, ieIdx, __LINE__);
7750 if(ieIdx < elementCnt)
7754 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7755 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
7756 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7757 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
7758 ricSubsDelFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7759 ricSubsDelFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7762 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7763 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7764 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7765 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
7766 ricSubsDelFailureIe->value.choice.RANfunctionID = ranFuncId;
7769 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7770 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
7771 ricSubsDelFailureIe->criticality = CriticalityE2_ignore;
7772 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_CauseE2;
7773 fillE2Cause(&ricSubsDelFailureIe->value.choice.CauseE2, failureCause);
7775 /* Prints the Msg formed */
7776 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7777 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7779 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7780 if(encRetVal.encoded == ENCODE_FAIL)
7782 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Failure Message (at %s)\n",\
7783 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7788 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Failure Message \n");
7789 #ifdef DEBUG_ASN_PRINT
7790 for(int i=0; i< encBufSize; i++)
7792 printf("%x",encBuf[i]);
7797 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7799 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Failure Message");
7807 FreeRicSubscriptionDeleteFailure(e2apMsg);
7812 /*******************************************************************
7814 * @brief Free RIC Subscription Delete Response Message
7818 * Function : FreeRicSubscriptionDeleteResponse
7820 * Functionality: Free RIC Subscription Delete Response
7822 * @param E2AP Message PDU
7825 ******************************************************************/
7826 void FreeRicSubscriptionDeleteResponse(E2AP_PDU_t *e2apMsg)
7829 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7833 if(e2apMsg->choice.successfulOutcome)
7835 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7836 if(ricSubsDelRsp->protocolIEs.list.array)
7838 for(ieIdx = 0; ieIdx < ricSubsDelRsp->protocolIEs.list.count; ieIdx++)
7840 DU_FREE(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7842 DU_FREE(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7844 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7846 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7850 /*******************************************************************
7852 * @brief Builds and Send RIC Subscription delete Response
7856 * Function : BuildAndSendRicSubscriptionDeleteResponse
7858 * Functionality: Build and send RIC subscription delete Response.
7863 * @return ROK - success
7866 ******************************************************************/
7867 uint8_t BuildAndSendRicSubscriptionDeleteResponse(uint16_t ranFuncId, RicRequestId requestId)
7869 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7870 E2AP_PDU_t *e2apMsg = NULLP;
7871 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7872 RICsubscriptionDeleteResponse_IEs_t *ricSubsDelRspIe = NULLP;
7873 asn_enc_rval_t encRetVal; /* Encoder return value */
7877 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Response Message\n");
7879 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7880 if(e2apMsg == NULLP)
7882 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7886 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7887 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7888 if(e2apMsg->choice.successfulOutcome == NULLP)
7890 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7893 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7894 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7895 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse;
7898 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7901 ricSubsDelRsp->protocolIEs.list.count = elementCnt;
7902 ricSubsDelRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteResponse_IEs_t *);
7904 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7905 if(ricSubsDelRsp->protocolIEs.list.array == NULLP)
7907 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7911 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7913 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7914 if(ricSubsDelRsp->protocolIEs.list.array[ieIdx] == NULLP)
7916 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7917 __func__, ieIdx, __LINE__);
7921 if(ieIdx < elementCnt)
7925 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7926 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
7927 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7928 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
7929 ricSubsDelRspIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7930 ricSubsDelRspIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7933 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7934 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7935 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7936 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
7937 ricSubsDelRspIe->value.choice.RANfunctionID = ranFuncId;
7939 /* Prints the Msg formed */
7940 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7941 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7943 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7944 if(encRetVal.encoded == ENCODE_FAIL)
7946 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Response Message (at %s)\n",\
7947 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7952 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Response Message \n");
7953 #ifdef DEBUG_ASN_PRINT
7954 for(int i=0; i< encBufSize; i++)
7956 printf("%x",encBuf[i]);
7961 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7963 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Response Message");
7971 FreeRicSubscriptionDeleteResponse(e2apMsg);
7975 /*******************************************************************
7977 * @brief Free RIC Subscription Delete Request Message
7981 * Function : freeAperDecodingOfRicSubsDeleteReq
7983 * Functionality: Free RIC Subscription Delete Request
7985 * @param E2AP Message PDU
7988 ******************************************************************/
7989 void freeAperDecodingOfRicSubsDeleteReq(E2AP_PDU_t *e2apMsg)
7992 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
7996 if(e2apMsg->choice.initiatingMessage)
7998 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
7999 if(ricSubsDelReq->protocolIEs.list.array)
8001 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
8003 if(ricSubsDelReq->protocolIEs.list.array[ieIdx])
8005 free(ricSubsDelReq->protocolIEs.list.array[ieIdx]);
8008 free(ricSubsDelReq->protocolIEs.list.array);
8014 /*******************************************************************
8016 * @brief Process RIC Subscription delete request
8020 * Function : procRicSubscriptionDeleteRequest
8022 * Functionality: Process RIC subscription delete request.
8023 * Fetch RAN Function and RIC subscription to be deleted.
8024 * Send statistics delete request to MAC for all action sequence
8025 * within this RIC subscription.
8027 * @params[in] E2AP PDU
8030 ******************************************************************/
8031 void procRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
8034 uint16_t ranFuncId = 0;
8035 bool procFailure = false;
8036 RicRequestId ricReqId;
8037 RanFunction *ranFuncDb = NULLP;
8038 CmLList *ricSubsNode = NULLP;
8039 RicSubscription *ricSubsDb = NULLP;
8040 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
8041 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
8043 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Delete Request", __func__);
8048 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
8052 if(!e2apMsg->choice.initiatingMessage)
8054 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
8058 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
8059 if(!ricSubsDelReq->protocolIEs.list.array)
8061 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
8065 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
8067 if(!ricSubsDelReq->protocolIEs.list.array[ieIdx])
8069 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
8073 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
8074 switch(ricSubsDelReqIe->id)
8076 case ProtocolIE_IDE2_id_RICrequestID:
8078 memset(&ricReqId, 0, sizeof(RicRequestId));
8079 ricReqId.requestorId = ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID;
8080 ricReqId.instanceId = ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID;
8084 case ProtocolIE_IDE2_id_RANfunctionID:
8086 ranFuncId = ricSubsDelReqIe->value.choice.RANfunctionID;
8087 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
8090 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
8095 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
8098 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
8099 __func__, ricReqId.requestorId, ricReqId.instanceId);
8104 if(BuildAndSendStatsDeleteReq(ricSubsDb, true) != ROK)
8106 DU_LOG("\nERROR --> E2AP : Failed to build and send ric subscription delete req to du layers");
8113 } /* End of switch for Protocol IE Id */
8117 } /* End of for loop for Protocol IE list */
8122 freeAperDecodingOfRicSubsDeleteReq(e2apMsg);
8126 /*******************************************************************
8128 * @brief Deallocate the memory allocated for E2 node configuration
8129 * update ack msg by aper decoder
8133 * Function : freeAperDecodingOfE2NodeConfigUpdateAck
8136 * - Deallocate the memory allocated for E2 node configuration
8137 * update ack msg by aper decoder
8139 * @params[in] E2AP_PDU_t *e2apMsg
8140 * @return ROK - success
8143 * ****************************************************************/
8145 void freeAperDecodingOfE2NodeConfigUpdateAck(E2nodeConfigurationUpdateAcknowledge_t *updateAckMsg)
8147 uint8_t arrIdx =0, e2NodeConfigIdx=0;
8148 E2nodeComponentConfigUpdateAck_ItemIEs_t *updateAckItemIe=NULL;
8149 E2nodeComponentConfigUpdateAck_List_t *updateAckList=NULL;
8150 E2nodeComponentConfigRemovalAck_ItemIEs_t *removalAckItemIe=NULL;
8151 E2nodeComponentConfigRemovalAck_List_t *removalAckList=NULL;
8152 E2nodeComponentConfigAdditionAck_ItemIEs_t *additionAckItemIte=NULL;
8153 E2nodeComponentConfigAdditionAck_List_t *additionAckList=NULL;
8155 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULLP;
8156 if(updateAckMsg->protocolIEs.list.array != NULLP)
8158 for(arrIdx = 0; arrIdx < updateAckMsg->protocolIEs.list.count; arrIdx++)
8160 if(updateAckMsg->protocolIEs.list.array[arrIdx])
8162 switch(updateAckMsg->protocolIEs.list.array[arrIdx]->id)
8164 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8166 additionAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8167 if(additionAckList->list.array)
8169 for(e2NodeConfigIdx=0; e2NodeConfigIdx<additionAckList->list.count; e2NodeConfigIdx++)
8171 additionAckItemIte = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) additionAckList->list.array[e2NodeConfigIdx];
8172 if(additionAckItemIte)
8174 switch(additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present)
8176 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8178 f1InterfaceInfo = additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8179 free(f1InterfaceInfo->gNB_DU_ID.buf);
8180 free(f1InterfaceInfo);
8186 free(additionAckItemIte);
8188 free(additionAckList->list.array);
8193 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8195 updateAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8196 if(updateAckList->list.array)
8198 for(e2NodeConfigIdx=0; e2NodeConfigIdx<updateAckList->list.count; e2NodeConfigIdx++)
8200 updateAckItemIe = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) updateAckList->list.array[e2NodeConfigIdx];
8203 switch(updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.present)
8205 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8207 f1InterfaceInfo = updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8208 free(f1InterfaceInfo->gNB_DU_ID.buf);
8209 free(f1InterfaceInfo);
8215 free(updateAckItemIe);
8218 free(updateAckList->list.array);
8222 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8224 removalAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8225 if(removalAckList->list.array)
8227 for(e2NodeConfigIdx=0; e2NodeConfigIdx<removalAckList->list.count; e2NodeConfigIdx++)
8229 removalAckItemIe = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) removalAckList->list.array[e2NodeConfigIdx];
8230 if(removalAckItemIe)
8232 switch(removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.present)
8234 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8236 f1InterfaceInfo = removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8237 free(f1InterfaceInfo->gNB_DU_ID.buf);
8238 free(f1InterfaceInfo);
8244 free(removalAckItemIe);
8247 free(removalAckList->list.array);
8252 free(updateAckMsg->protocolIEs.list.array[arrIdx]);
8255 free(updateAckMsg->protocolIEs.list.array);
8259 /******************************************************************
8261 * @brief Processes the E2 node config update ack msg
8265 * Function :procE2NodeConfigUpdateAck
8267 * Functionality: Processes the E2 node config update ack msg
8269 * @params[in] E2AP_PDU_t ASN decoded E2AP message
8270 * @return ROK - success
8273 * ****************************************************************/
8275 void procE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
8278 uint16_t e2CfgIdx =0;
8279 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck =NULLP;
8280 E2nodeComponentConfigUpdateAck_List_t *e2NodeConfigUpdateAckList=NULLP;
8281 E2nodeComponentConfigUpdateAck_ItemIEs_t *e2NodeUpdateAckItem=NULLP;
8282 E2nodeComponentConfigRemovalAck_List_t *e2NodeConfigRemovalAckList=NULLP;
8283 E2nodeComponentConfigRemovalAck_ItemIEs_t *e2NodeRemovalAckItem=NULLP;
8284 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULLP;
8285 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAdditionAckItem=NULLP;
8287 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
8289 if(e2NodeConfigUpdateAck->protocolIEs.list.array)
8291 for(arrIdx =0; arrIdx<e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
8293 switch(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id)
8295 case ProtocolIE_IDE2_id_TransactionID:
8299 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8301 e2NodeConfigAdditionAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8302 if(e2NodeConfigAdditionAckList->list.array)
8304 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigAdditionAckList->list.count; e2CfgIdx++)
8306 e2NodeAdditionAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2CfgIdx];
8307 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAdditionAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
8308 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
8313 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8315 e2NodeConfigUpdateAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8316 if(e2NodeConfigUpdateAckList->list.array)
8318 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigUpdateAckList->list.count; e2CfgIdx++)
8320 e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[e2CfgIdx];
8321 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeUpdateAckItem->value.choice.E2nodeComponentConfigUpdateAck_Item,\
8322 ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck);
8327 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8329 e2NodeConfigRemovalAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8330 if(e2NodeConfigRemovalAckList->list.array)
8332 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigRemovalAckList->list.count; e2CfgIdx++)
8334 e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[e2CfgIdx];
8335 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeRemovalAckItem->value.choice.E2nodeComponentConfigRemovalAck_Item,\
8336 ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck);
8345 freeAperDecodingOfE2NodeConfigUpdateAck(e2NodeConfigUpdateAck);
8348 /*******************************************************************
8350 * @brief Deallocate the memory allocated for RemovalRequest msg
8354 * Function : FreeRemovalRequest
8357 * - freeing the memory allocated for RemovalRequest
8359 * @params[in] E2AP_PDU_t *e2apMsg
8360 * @return ROK - success
8363 * ****************************************************************/
8364 void FreeRemovalRequest(E2AP_PDU_t *e2apMsg)
8367 E2RemovalRequest_t *removalReq = NULLP;
8369 if(e2apMsg != NULLP)
8371 if(e2apMsg->choice.initiatingMessage != NULLP)
8373 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8374 if(removalReq->protocolIEs.list.array)
8376 for(ieIdx = 0; ieIdx < removalReq->protocolIEs.list.count; ieIdx++)
8378 DU_FREE(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8380 DU_FREE(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8382 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8384 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8388 /*******************************************************************
8390 * @brief Build and send the removal request msg
8394 * Function : BuildAndSendRemovalRequest
8397 * - Buld and send the removal request msg to E2 node
8399 * @return ROK - success
8402 * ****************************************************************/
8404 uint8_t BuildAndSendRemovalRequest()
8406 uint16_t transId = 0;
8407 uint8_t ret = RFAILED;
8408 uint8_t ieIdx = 0, elementCnt = 0;
8409 E2AP_PDU_t *e2apMsg = NULLP;
8410 E2RemovalRequest_t *removalReq = NULLP;
8411 asn_enc_rval_t encRetVal; /* Encoder return value */
8413 DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
8417 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8418 if(e2apMsg == NULLP)
8420 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8424 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
8425 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8426 if(e2apMsg->choice.initiatingMessage == NULLP)
8428 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8432 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2removal;
8433 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
8434 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2RemovalRequest;
8435 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8438 removalReq->protocolIEs.list.count = elementCnt;
8439 removalReq->protocolIEs.list.size = elementCnt * sizeof(E2RemovalRequestIEs_t *);
8441 DU_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8442 if(!removalReq->protocolIEs.list.array)
8444 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8448 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
8450 DU_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8451 if(!removalReq->protocolIEs.list.array[ieIdx])
8453 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8458 /* In case of failure */
8459 if(ieIdx < elementCnt)
8463 removalReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8464 removalReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8465 removalReq->protocolIEs.list.array[ieIdx]->value.present = E2RemovalRequestIEs__value_PR_TransactionID;
8466 transId = assignTransactionId();
8467 removalReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8469 /* Prints the Msg formed */
8470 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8472 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8474 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
8476 if(encRetVal.encoded == ENCODE_FAIL)
8478 DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
8479 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8484 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
8485 #ifdef DEBUG_ASN_PRINT
8486 for(int i=0; i< encBufSize; i++)
8488 printf("%x",encBuf[i]);
8492 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8494 DU_LOG("\nERROR --> E2AP : Sending removal request failed");
8500 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
8501 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
8505 /* Free all memory */
8506 FreeRemovalRequest(e2apMsg);
8511 /******************************************************************
8513 * @brief Deallocation of memory allocated by aper decoder
8514 * for Removal failure
8518 * Function : freeAperDecodingOfE2RemovalFailure
8520 * Functionality: Deallocation of memory allocated by aper decoder
8521 * for Removal failure
8523 * @params[in] Pointer to removalFailure
8526 * ****************************************************************/
8527 void freeAperDecodingOfE2RemovalFailure(E2RemovalFailure_t *removalFailure)
8533 if(removalFailure->protocolIEs.list.array)
8535 for(arrIdx=0; arrIdx<removalFailure->protocolIEs.list.count; arrIdx++)
8537 if(removalFailure->protocolIEs.list.array[arrIdx])
8539 free(removalFailure->protocolIEs.list.array[arrIdx]);
8542 free(removalFailure->protocolIEs.list.array);
8547 /******************************************************************
8549 * @brief Processes the E2 removal failure msg
8553 * Function : procE2RemovalFailure
8555 * Functionality: Processes the E2 removal failure msg
8558 * E2AP_PDU_t *e2apMsg
8562 * ****************************************************************/
8563 void ProcE2RemovalFailure(E2AP_PDU_t *e2apMsg)
8567 CauseE2_t *cause = NULLP;
8568 E2RemovalFailure_t *e2RemovalFailure=NULLP;
8570 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
8572 if(!e2RemovalFailure->protocolIEs.list.array)
8574 DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
8578 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
8580 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
8582 switch(e2RemovalFailure->protocolIEs.list.array[ieIdx]->id)
8584 case ProtocolIE_IDE2_id_TransactionID:
8586 transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8587 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8588 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8590 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8594 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8598 case ProtocolIE_IDE2_id_CauseE2:
8600 cause = &e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
8601 printE2ErrorCause(cause);
8606 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
8612 freeAperDecodingOfE2RemovalFailure(e2RemovalFailure);
8615 /******************************************************************
8617 * @brief Deallocation of memory allocated by aper decoder
8618 * for Removal failure
8622 * Function : freeAperDecodingOfE2RemovalResponse
8624 * Functionality: Deallocation of memory allocated by aper decoder
8625 * for Removal failure
8627 * @params[in] Pointer to removalResponse
8630 * ****************************************************************/
8631 void freeAperDecodingOfE2RemovalResponse(E2RemovalResponse_t *removalResponse)
8637 if(removalResponse->protocolIEs.list.array)
8639 for(arrIdx=0; arrIdx<removalResponse->protocolIEs.list.count; arrIdx++)
8641 if(removalResponse->protocolIEs.list.array[arrIdx])
8643 free(removalResponse->protocolIEs.list.array[arrIdx]);
8646 free(removalResponse->protocolIEs.list.array);
8651 /*******************************************************************
8653 * @brief process the E2 Removal Response
8657 * Function : ProcE2RemovalResponse
8659 * Functionality: Process E2 Removal Response
8662 * E2AP_PDU_t *e2apMsg
8665 ******************************************************************/
8667 void ProcE2RemovalResponse(E2AP_PDU_t *e2apMsg)
8671 E2RemovalResponse_t *removalRsp = NULLP;
8673 removalRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
8675 if(!removalRsp->protocolIEs.list.array)
8677 DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
8681 for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
8683 if(removalRsp->protocolIEs.list.array[ieIdx])
8685 switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
8687 case ProtocolIE_IDE2_id_TransactionID:
8689 transId = removalRsp->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8690 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8691 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8693 DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
8694 cmInetClose(&ricParams.sockFd);
8695 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8696 removeE2NodeInformation();
8700 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8706 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
8713 freeAperDecodingOfE2RemovalResponse(removalRsp);
8716 /*******************************************************************
8718 * @brief Deallocate the memory allocated for E2 Connection Update Failure
8722 * Function : FreeE2ConnectionUpdateFailure
8725 * - freeing the memory allocated for E2ConnectionUpdateFailure
8727 * @params[in] E2AP_PDU_t *e2apMsg
8728 * @return ROK - success
8731 * ****************************************************************/
8732 void FreeE2ConnectionUpdateFailure(E2AP_PDU_t *e2apMsg)
8735 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8737 if(e2apMsg != NULLP)
8739 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
8741 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8742 if(e2ConnectionUpdateFailure->protocolIEs.list.array)
8744 for(ieIdx=0; ieIdx < e2ConnectionUpdateFailure->protocolIEs.list.count; ieIdx++)
8746 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8748 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8750 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8752 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8756 /*******************************************************************
8758 * @brief Buld and send the E2 Connection Update Failure msg
8762 * Function : BuildAndSendE2ConnectionUpdateFailure
8765 * - Buld and send the E2 Connection Update Failure Message
8769 * @return ROK - success
8772 * ****************************************************************/
8774 uint8_t BuildAndSendE2ConnectionUpdateFailure(uint16_t transId, E2FailureCause failureCause)
8776 uint8_t ieIdx = 0, elementCnt = 0;
8777 uint8_t ret = RFAILED;
8778 E2AP_PDU_t *e2apMsg = NULLP;
8779 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8780 asn_enc_rval_t encRetVal; /* Encoder return value */
8782 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Failure Message\n");
8785 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8786 if(e2apMsg == NULLP)
8788 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8791 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
8793 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8794 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
8796 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8800 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
8801 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
8802 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure;
8803 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8806 e2ConnectionUpdateFailure->protocolIEs.list.count = elementCnt;
8807 e2ConnectionUpdateFailure->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateFailure_IEs_t *);
8808 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8809 if(!e2ConnectionUpdateFailure->protocolIEs.list.array)
8811 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8815 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
8817 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8818 if(!e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx])
8820 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8824 if(ieIdx < elementCnt)
8828 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8829 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8830 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_TransactionID;
8831 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8835 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
8836 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
8837 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_CauseE2;
8838 fillE2Cause(&e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, failureCause);
8840 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8842 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8844 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
8845 if(encRetVal.encoded == ENCODE_FAIL)
8847 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update failure structure (at %s)\n",\
8848 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8853 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Failure \n");
8854 for(int i=0; i< encBufSize; i++)
8856 DU_LOG("%x",encBuf[i]);
8861 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8863 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Failure");
8871 FreeE2ConnectionUpdateFailure(e2apMsg);
8875 /*******************************************************************
8877 * @brief fill E2 connection update item
8881 * Function : fillE2connectionUpdateItem
8883 * Functionality: fill E2 connection update item
8886 * E2connectionUpdate Item to be filled
8890 * @return ROK - success
8892 * ****************************************************************/
8894 uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId, uint32_t ipAddress, AssocUsage usage)
8896 CauseE2_t *cause=NULLP;
8897 TNLusage_t *tnlUsage=NULLP;
8898 E2FailureCause failureCause;
8899 TNLinformation_t *tnlInformation = NULLP;
8900 E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
8901 E2connectionSetupFailed_Item_t *connectionRemoveITem=NULLP;
8905 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8907 connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
8908 tnlInformation = &connectionModifyItem->tnlInformation;
8909 tnlUsage = &connectionModifyItem->tnlUsage;
8913 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8915 connectionRemoveITem = (E2connectionSetupFailed_Item_t*)connectionInfo;
8916 tnlInformation= &connectionRemoveITem->tnlInformation;
8917 cause = &connectionRemoveITem->cause;
8924 tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
8925 DU_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
8926 if(!tnlInformation->tnlAddress.buf)
8928 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8932 tnlInformation->tnlAddress.buf[3] = ipAddress & 0xFF;
8933 tnlInformation->tnlAddress.buf[2] = (ipAddress>> 8) & 0xFF;
8934 tnlInformation->tnlAddress.buf[1] = (ipAddress>> 16) & 0xFF;
8935 tnlInformation->tnlAddress.buf[0] = (ipAddress>> 24) & 0xFF;
8936 tnlInformation->tnlAddress.bits_unused = 0;
8940 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8945 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8947 failureCause.causeType = E2_TRANSPORT;
8948 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
8949 fillE2Cause(cause, failureCause);
8959 /*******************************************************************
8961 * @brief Build E2 connection modification list
8965 * Function :BuildE2ConnectionUpdateList
8967 * Functionality: Build E2 connection modification list
8970 * E2 connection update list to be filled
8971 * Count of E2 connection to be added in the list
8972 * Received list of E2 connection
8974 * @return ROK - success
8976 * ****************************************************************/
8978 uint8_t BuildE2ConnectionUpdateList(E2connectionUpdate_List_t *connectionSetupList, uint8_t count, E2ConnectionItem *tmpConnectionList)
8981 E2connectionUpdate_ItemIEs_t *connectionSetupItem=NULLP;
8983 connectionSetupList->list.count = count;
8985 connectionSetupList->list.size = connectionSetupList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
8986 DU_ALLOC(connectionSetupList->list.array, connectionSetupList->list.size);
8987 if(connectionSetupList->list.array)
8989 for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
8991 DU_ALLOC(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
8992 if(connectionSetupList->list.array[arrIdx] == NULLP)
8994 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8997 connectionSetupItem = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
8998 connectionSetupItem->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
8999 connectionSetupItem->criticality= CriticalityE2_ignore;
9000 connectionSetupItem->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
9001 if(fillE2connectionUpdateItem((PTR)&connectionSetupItem->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item,\
9002 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
9004 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
9012 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9018 /*******************************************************************
9020 * @brief Build E2 connection setup failed list
9024 * Function : BuildE2ConnectionSetupFailedList
9026 * Functionality: Build E2 connection setup failed list
9029 * E2 connection setup failed list to be filled
9030 * Count of E2 connection to be added in the list
9031 * Received list of E2 connection
9033 * @return ROK - success
9035 * ****************************************************************/
9037 uint8_t BuildE2ConnectionSetupFailedList(E2connectionSetupFailed_List_t *setupFailedList, uint8_t count, E2ConnectionItem *tmpConnectionList)
9040 E2connectionSetupFailed_ItemIEs_t *setupFailedItem=NULLP;
9042 setupFailedList->list.count = 1;
9044 setupFailedList->list.size = setupFailedList->list.count*sizeof(E2connectionSetupFailed_ItemIEs_t *);
9045 DU_ALLOC(setupFailedList->list.array, setupFailedList->list.size);
9046 if(setupFailedList->list.array)
9048 for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
9050 DU_ALLOC(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9051 if(setupFailedList->list.array[arrIdx] == NULLP)
9053 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9056 setupFailedItem = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
9057 setupFailedItem->id = ProtocolIE_IDE2_id_E2connectionSetupFailed_Item;
9058 setupFailedItem->criticality= CriticalityE2_ignore;
9059 setupFailedItem->value.present = E2connectionSetupFailed_ItemIEs__value_PR_E2connectionSetupFailed_Item;
9060 if(fillE2connectionUpdateItem((PTR)&setupFailedItem->value.choice.E2connectionSetupFailed_Item, ProtocolIE_IDE2_id_E2connectionSetupFailed_Item,\
9061 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
9063 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection failed to update item");
9071 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9077 /*******************************************************************
9079 * @brief Deallocate the memory allocated for E2 Connection
9084 * Function :FreeE2ConnectionUpdateAcknowledge
9087 * - freeing the memory allocated for E2 Connection
9090 * @params[in] E2AP_PDU_t *e2apMsg
9091 * @return ROK - success
9094 * ****************************************************************/
9096 void FreeE2ConnectionUpdateAcknowledge(E2AP_PDU_t *e2apMsg)
9098 uint8_t ieIdx =0, arrIdx=0;
9099 E2connectionUpdateAcknowledge_t *connectionUpdate = NULLP;
9100 E2connectionUpdate_List_t *connectionSetupList = NULLP;
9101 E2connectionSetupFailed_List_t *setupFailedList = NULLP;
9103 if(e2apMsg != NULLP)
9105 if(e2apMsg->choice.successfulOutcome != NULLP)
9107 connectionUpdate = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9108 if(connectionUpdate->protocolIEs.list.array)
9110 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9112 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9114 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9116 case ProtocolIE_IDE2_id_TransactionID:
9119 case ProtocolIE_IDE2_id_E2connectionSetup:
9121 connectionSetupList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9122 if(connectionSetupList->list.array)
9124 for(arrIdx = 0; arrIdx < connectionSetupList->list.count; arrIdx++)
9126 DU_FREE(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
9128 DU_FREE(connectionSetupList->list.array, connectionSetupList->list.size);
9133 case ProtocolIE_IDE2_id_E2connectionSetupFailed:
9135 setupFailedList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
9136 if(setupFailedList->list.array)
9138 for(arrIdx = 0; arrIdx < setupFailedList->list.count; arrIdx++)
9140 DU_FREE(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9142 DU_FREE(setupFailedList->list.array, setupFailedList->list.size);
9147 DU_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9150 DU_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
9152 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9154 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
9158 /*******************************************************************
9160 * @brief Buld and send the E2 Connection Update Acknowledge msg
9164 * Function : BuildAndSendE2ConnectionUpdateAcknowledge
9167 * - Buld and send the E2 Connection Update Acknowledge Message
9170 * List of E2 connection needs to fill in IE
9171 * @return ROK - success
9174 * ****************************************************************/
9176 uint8_t BuildAndSendE2ConnectionUpdateAcknowledge(uint16_t transId, E2ConnectionList connectionInfoList)
9178 uint8_t ieIdx = 0, elementCnt = 0;
9179 uint8_t ret = RFAILED;
9180 E2AP_PDU_t *e2apMsg = NULLP;
9181 asn_enc_rval_t encRetVal;
9182 E2connectionUpdateAcknowledge_t *e2ConnectionUpdateAcknowledge=NULLP;
9184 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Acknowledge Message\n");
9187 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
9188 if(e2apMsg == NULLP)
9190 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9193 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
9195 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9196 if(e2apMsg->choice.successfulOutcome == NULLP)
9198 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9202 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
9203 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
9204 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge;
9205 e2ConnectionUpdateAcknowledge = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9208 if(connectionInfoList.numOfE2ConnectionSetup)
9210 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9213 e2ConnectionUpdateAcknowledge->protocolIEs.list.count = elementCnt;
9214 e2ConnectionUpdateAcknowledge->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateAck_IEs_t*);
9215 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array, e2ConnectionUpdateAcknowledge->protocolIEs.list.size);
9216 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array)
9218 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9222 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
9224 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9225 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx])
9227 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9231 if(ieIdx < elementCnt)
9235 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
9236 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9237 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_TransactionID;
9238 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
9240 if(connectionInfoList.numOfE2ConnectionSetup)
9243 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetup;
9244 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9245 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionUpdate_List;
9246 if(BuildE2ConnectionUpdateList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List, \
9247 connectionInfoList.numOfE2ConnectionSetup, connectionInfoList.setupE2Connection) != ROK)
9249 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection setup list");
9254 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9257 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetupFailed;
9258 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9259 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionSetupFailed_List;
9260 if(BuildE2ConnectionSetupFailedList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List, \
9261 connectionInfoList.numOfE2ConnectionFailedToSetup, connectionInfoList.failedToSetupE2Connection) != ROK)
9263 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection failed to setup list");
9268 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
9270 memset(encBuf, 0, ENC_BUF_MAX_LEN);
9272 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
9273 if(encRetVal.encoded == ENCODE_FAIL)
9275 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update acknowledge failure structure (at %s)\n",\
9276 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9281 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Acknowledge \n");
9282 for(int i=0; i< encBufSize; i++)
9284 DU_LOG("%x",encBuf[i]);
9289 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
9291 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Acknowledge");
9299 FreeE2ConnectionUpdateAcknowledge(e2apMsg);
9303 /******************************************************************
9305 * @brief Deallocation of memory allocated by aper decoder for
9306 * E2 Connection Update
9310 * Function :freeAperDecodingOfE2ConnectionUpdate
9312 * Functionality: Deallocation of memory allocated by aper decoder for
9313 * E2 Connection Update
9315 * @params[in] Pointer to connectionUpdate
9318 * ****************************************************************/
9320 void freeAperDecodingOfE2ConnectionUpdate(E2connectionUpdate_t *connectionUpdate)
9322 uint8_t ieIdx =0, arrIdx=0;
9323 E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
9324 E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
9326 if(connectionUpdate->protocolIEs.list.array)
9328 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9330 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9332 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9334 case ProtocolIE_IDE2_id_TransactionID:
9337 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9339 connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9340 if(connectionToBeModifyList->list.array)
9342 for(arrIdx= 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
9344 free(connectionToBeModifyList->list.array[arrIdx]);
9346 free(connectionToBeModifyList->list.array);
9350 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9352 connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
9353 if(connectionToBeRemoveList->list.array)
9355 for(arrIdx= 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
9357 free(connectionToBeRemoveList->list.array[arrIdx]);
9359 free(connectionToBeRemoveList->list.array);
9364 free(connectionUpdate->protocolIEs.list.array[ieIdx]);
9367 free(connectionUpdate->protocolIEs.list.array);
9371 /*******************************************************************
9373 * @brief Handling of E2 connection modification Ie
9377 * Function : handleE2ConnectionModification
9379 * Functionality: Handling of E2 connection modification Ie
9382 * E2 Connection update list
9383 * E2 connection list which needs to be filled
9386 ******************************************************************/
9388 void handleE2ConnectionModification(E2connectionUpdate_List_t *connectionUpdateList, E2ConnectionList *connectionInfoList)
9390 uint32_t ipAddress=0;
9391 bool infoFound = false;
9392 uint8_t arrIdx=0,idx=0, count =0;
9393 E2connectionUpdate_ItemIEs_t *connectionModifyItem=NULLP;
9395 if(connectionUpdateList->list.array)
9397 for(arrIdx = 0; arrIdx < connectionUpdateList->list.count; arrIdx++)
9399 connectionModifyItem= (E2connectionUpdate_ItemIEs_t*)connectionUpdateList->list.array[arrIdx];
9400 bitStringToInt(&connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlInformation.tnlAddress, &ipAddress);
9401 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9403 /* If the TNL information is found in the data base, update the
9404 * information in the database */
9405 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9407 duCb.e2apDb.tnlAssoc[idx].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9413 /* If the TNL information is found in the data base, then add the
9414 * information in setupE2Connection array else add in failedToSetupE2Connection array */
9415 if(infoFound == true)
9417 count =connectionInfoList->numOfE2ConnectionSetup;
9418 connectionInfoList->setupE2Connection[count].ipV4Addr = duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr;
9419 connectionInfoList->setupE2Connection[count].usage = duCb.e2apDb.tnlAssoc[idx].usage;
9420 connectionInfoList->numOfE2ConnectionSetup++;
9424 count = connectionInfoList->numOfE2ConnectionFailedToSetup;
9425 connectionInfoList->failedToSetupE2Connection[count].ipV4Addr = ipAddress;
9426 connectionInfoList->failedToSetupE2Connection[count].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9427 connectionInfoList->numOfE2ConnectionFailedToSetup++;
9434 /*******************************************************************
9436 * @brief Handling of E2 connection removal Ie
9440 * Function : handleE2ConnectionRemoval
9442 * Functionality: Handling of E2 connection removal Ie
9445 * E2 Connection removal List
9448 ******************************************************************/
9450 void handleE2ConnectionRemoval(E2connectionUpdateRemove_List_t *connectionRemovalList)
9452 uint32_t ipAddress=0;
9453 uint8_t arrIdx=0,idx=0;
9454 E2connectionUpdateRemove_ItemIEs_t *connectionRemovalItem=NULLP;
9456 if(connectionRemovalList->list.array)
9458 for(arrIdx = 0; arrIdx < connectionRemovalList->list.count; arrIdx++)
9460 connectionRemovalItem= (E2connectionUpdateRemove_ItemIEs_t*)connectionRemovalList->list.array[arrIdx];
9461 bitStringToInt(&connectionRemovalItem->value.choice.E2connectionUpdateRemove_Item.tnlInformation.tnlAddress, &ipAddress);
9462 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9464 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9466 cmInetClose(&ricParams.sockFd);
9467 removeE2NodeInformation();
9476 /*******************************************************************
9478 * @brief Process e2 connection update received from RIC
9482 * Function : procE2ConnectionUpdate
9484 * Functionality: Process e2 connection update received from RIC
9486 * @param E2AP_PDU_t *e2apMsg
9489 ******************************************************************/
9491 void procE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
9494 uint16_t transId =0;
9495 bool invalidTransId = false, connectionFailedToUpdate=false;
9496 E2FailureCause failureCause;
9497 E2ConnectionList connectionInfoList;
9498 E2connectionUpdate_t *connectionUpdate=NULLP;
9500 DU_LOG("\nINFO --> E2AP : E2 connection update received");
9501 connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
9503 memset(&connectionInfoList, 0, sizeof(E2ConnectionList));
9504 for(arrIdx=0; arrIdx<connectionUpdate->protocolIEs.list.count; arrIdx++)
9506 switch(connectionUpdate->protocolIEs.list.array[arrIdx]->id)
9508 case ProtocolIE_IDE2_id_TransactionID:
9510 transId = connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
9513 failureCause.causeType = E2_PROTOCOL;
9514 failureCause.cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
9515 invalidTransId = true;
9520 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9522 handleE2ConnectionModification(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdate_List,\
9523 &connectionInfoList);
9524 if((connectionInfoList.numOfE2ConnectionSetup == 0) && (connectionInfoList.numOfE2ConnectionFailedToSetup > 0))
9526 failureCause.causeType = E2_TRANSPORT;
9527 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
9528 connectionFailedToUpdate =true;
9534 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9536 handleE2ConnectionRemoval(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdateRemove_List);
9542 DU_LOG("\nERROR --> E2AP : Invalid IE received[%ld]",connectionUpdate->protocolIEs.list.array[arrIdx]->id);
9547 if(invalidTransId == true || connectionFailedToUpdate ==true)
9551 if(invalidTransId == true || connectionFailedToUpdate == true)
9553 if(BuildAndSendE2ConnectionUpdateFailure(transId, failureCause) != ROK)
9555 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update failure");
9560 if(BuildAndSendE2ConnectionUpdateAcknowledge(transId, connectionInfoList) != ROK)
9562 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update ack");
9566 freeAperDecodingOfE2ConnectionUpdate(connectionUpdate);
9569 /*******************************************************************
9571 * @brief Free RIC Subscription action to be added list
9575 * Function : freeAperDecodingOfRicSubsActionToBeAdded
9577 * Functionality: Free the RIC Subscription action to be added list
9579 * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
9582 * ****************************************************************/
9583 void freeAperDecodingOfRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
9585 uint8_t elementIdx = 0;
9586 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
9588 if(subsDetails->list.array)
9590 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9592 if(subsDetails->list.array[elementIdx])
9594 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
9595 free(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf);
9596 free(subsDetails->list.array[elementIdx]);
9599 free(subsDetails->list.array);
9603 /*******************************************************************
9605 * @brief Deallocation of memory allocated by aper decoder for
9606 * RIC Subscription action to be removed list
9610 * Function : freeAperDecodingOfRicSubsActionToBeRemoved
9612 * Functionality: Free the RIC Subscription action to be removed list
9614 * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
9617 * ****************************************************************/
9618 void freeAperDecodingOfRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
9620 uint8_t elementIdx = 0;
9622 if(subsDetails->list.array)
9624 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9626 if(subsDetails->list.array[elementIdx])
9628 free(subsDetails->list.array[elementIdx]);
9631 free(subsDetails->list.array);
9635 /*******************************************************************
9637 * @brief Deallocation of memory allocated by aper decoder for
9638 * RIC Subscription action to be modify
9642 * Function : freeAperDecodingOfRicSubsActionToBeModified
9644 * Functionality: Free the RIC Subscription action to be modify
9646 * @params[in] RICactions_ToBeModifiedForModification_List_t List
9649 * ****************************************************************/
9650 void freeAperDecodingOfRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
9652 uint8_t elementIdx = 0;
9653 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
9655 if(subsDetails->list.array)
9657 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9659 if(subsDetails->list.array[elementIdx])
9661 actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx];
9662 if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
9664 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf);
9665 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition);
9667 free(subsDetails->list.array[elementIdx]);
9670 free(subsDetails->list.array);
9674 /*******************************************************************
9676 * @brief Deallocation of memory allocated by aper decoder for
9677 * RIC Subscription modification Request
9681 * Function freeAperDecodingOfRicSubsModificationReq
9683 * Functionality : Free RIC Subscription modification Request
9685 * @params[in] E2AP_PDU
9688 ******************************************************************/
9689 void freeAperDecodingOfRicSubsModificationReq(E2AP_PDU_t *e2apRicMsg)
9692 RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
9693 RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe;
9695 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
9697 if(ricSubscriptionModReq->protocolIEs.list.array)
9699 for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
9701 if(ricSubscriptionModReq->protocolIEs.list.array[idx])
9703 ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
9705 switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
9707 case ProtocolIE_IDE2_id_RICrequestID:
9710 case ProtocolIE_IDE2_id_RANfunctionID:
9713 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
9715 freeAperDecodingOfRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
9718 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
9720 freeAperDecodingOfRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
9723 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
9725 freeAperDecodingOfRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
9730 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
9736 free(ricSubscriptionModReq->protocolIEs.list.array[idx]);
9739 free(ricSubscriptionModReq->protocolIEs.list.array);
9742 /*******************************************************************
9744 * @brief Extract RIC Action to be added
9748 * Function : extractRicActionToBeAddedForModification
9750 * Functionality : This function :
9751 * - [Step -1] Traverse each AddedForModification item indexes.
9752 * - [Step -2] Add each action id related information in
9753 * RicSubscription Db.
9754 * - [Step -3] If failed to store then add action related info in
9755 * pending rsp's rejectedActionList.
9756 * - [Step -4] Else increment action added count
9757 * - [Step -5] If there is even 1 action that can be added,
9758 * return ROK, else RFAILED.
9760 * @params[in] RAN Function Database structure
9761 * RIC Subscription Info to be added to RAN function
9762 * RIC Action To Be AddedForModification List received from RIC
9764 * Pending Subs Mod Rsp Info
9765 * @return ROK - success
9768 ******************************************************************/
9769 uint8_t extractRicActionToBeAddedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9770 RICactions_ToBeAddedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9772 uint8_t actionAdded=0;
9773 CmLList *actionNode = NULLP;
9774 uint8_t actionIdx = 0;
9775 uint8_t ricActionId = 0;
9776 RICaction_ToBeAddedForModification_ItemIEs_t *actionItem = NULLP;
9778 if(actionList->list.array)
9780 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9783 actionItem =(RICaction_ToBeAddedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9784 switch(actionItem->id)
9786 case ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item:
9789 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeAddedForModification_Item,\
9790 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item, failureCause);
9795 subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].id = ricActionId;
9796 if(failureCause->causeType == E2_NOTHING)
9798 failureCause->causeType = E2_RIC_REQUEST;
9799 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
9801 memcpy(&subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].failureCause, \
9802 failureCause, sizeof(E2FailureCause));
9803 subsModRsp->addActionStatus.numOfRejectedActions++;
9813 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicAddedForModificationLst:%ld",actionItem->id);
9823 if(failureCause->causeType == E2_NOTHING)
9825 failureCause->causeType = E2_RIC_REQUEST;
9826 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
9831 /*******************************************************************
9833 * @brief Extract RIC Action to be Modified
9837 * Function : extractRicActionToBeModifiedForModification
9839 * Functionality : This function :
9840 * - [Step -1] Traverse each Modification item indexes.
9841 * - [Step -2] Find each action id related information in
9842 * RicSubscription Db.
9843 * - [Step -3] If not found store the action related info in pending
9844 * rsp's action rejected.
9845 * - [Step -4] If found store the new node in action seq list.
9846 * [Step -4.1] If action failed to store, add the action
9847 * info in pending subscription rsp's rejected list.
9848 * [Step -4.2] If action stored successfully, change the status
9849 * of added action to modified because action added as part of
9850 * ric subscription modification req.
9851 * - [Step -5] If there is even 1 action that can be modified,
9852 * return ROK, else RFAILED.
9854 * @params[in] RAN Function Database structure
9855 * RIC Subscription Info to be Modified to RAN function
9856 * RIC Action To Be ModifiedForModification List received from RIC
9858 * Pending Subs Mod Rsp Info
9859 * @return ROK - success
9862 ******************************************************************/
9863 uint8_t extractRicActionToBeModifiedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9864 RICactions_ToBeModifiedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9867 uint8_t actionIdx = 0;
9868 uint8_t actionFound=0;
9869 CmLList *actionNode = NULLP;
9870 ActionInfo *actionDb = NULLP;
9871 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
9873 if(actionList->list.array)
9875 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9878 actionItem =(RICaction_ToBeModifiedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9879 switch(actionItem->id)
9881 case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item:
9884 actionId=actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID;
9885 actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
9889 subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionDb->actionId;
9890 failureCause->causeType = E2_RIC_REQUEST;
9891 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
9892 memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \
9893 failureCause, sizeof(E2FailureCause));
9894 subsModRsp->modActionStatus.numOfRejectedActions++;
9900 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeModifiedForModification_Item,\
9901 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item, failureCause);
9906 subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionId;
9907 if(failureCause->causeType == E2_NOTHING)
9909 failureCause->causeType = E2_RIC_REQUEST;
9910 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
9912 memcpy(&subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \
9913 failureCause, sizeof(E2FailureCause));
9914 subsModRsp->addActionStatus.numOfRejectedActions++;
9919 actionDb = (ActionInfo*)actionNode->node;
9920 actionDb->action=CONFIG_MOD;
9928 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicModifiedForModificationLst:%ld",actionItem->id);
9941 /*******************************************************************
9943 * @brief Extract RIC Action to be Removed
9947 * Function : extractRicActionToBeRemovedForModification
9949 * Functionality : This function :
9950 * - [Step -1] Traverse each RemovedForModification item indexes.
9951 * - [Step -2] Find each action id related information in
9952 * RicSubscription Db.
9953 * - [Step -3] If not found store the action related info in pending
9954 * rsp's rejectedActionList.
9955 * - [Step -4] If found mark action's status CONFIG_DEL.
9956 * - [Step -5] If there is even 1 action that can be Removed,
9957 * return ROK, else RFAILED.
9959 * @params[in] RAN Function Database structure
9960 * RIC Subscription Info to be Removed to RAN function
9961 * RIC Action To Be RemovedForModification List received from RIC
9963 * Pending ric subs mod Rsp Info to store failure result
9964 * @return ROK - success
9967 ******************************************************************/
9968 uint8_t extractRicActionToBeRemovedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9969 RICactions_ToBeRemovedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9972 uint8_t actionIdx = 0;
9973 uint8_t actionFound=0;
9974 CmLList *actionNode = NULLP;
9975 ActionInfo *actionDb = NULLP;
9976 RICaction_ToBeRemovedForModification_ItemIEs_t *actionItem = NULLP;
9978 if(actionList->list.array)
9980 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9983 actionItem =(RICaction_ToBeRemovedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9984 switch(actionItem->id)
9986 case ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item:
9989 actionId = actionItem->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID;
9990 actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
9994 subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].id = actionDb->actionId;
9995 if(failureCause->causeType == E2_NOTHING)
9997 failureCause->causeType = E2_RIC_REQUEST;
9998 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
10000 memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].failureCause, \
10001 failureCause, sizeof(E2FailureCause));
10002 subsModRsp->removeActionStatus.numOfRejectedActions++;
10007 actionDb->action=CONFIG_DEL;
10013 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicRemovedForModificationLst:%ld",actionItem->id);
10026 /*******************************************************************
10028 * @brief Process RIC Subscription modification request
10032 * Function : procRicSubscriptionModificationRequest
10034 * Functionality: Process RIC subscription modification request.
10036 * @params[in] E2AP PDU
10039 ******************************************************************/
10040 void procRicSubscriptionModificationRequest(E2AP_PDU_t *e2apMsg)
10043 uint16_t ranFuncId = 0;
10044 RicRequestId ricReqId;
10045 E2FailureCause failureCause;
10046 bool procFailure = false;
10047 bool addActionIeProcessed=false;
10048 bool modActionIeProcessed =false;
10049 bool removeActionIeProcessed =false;
10050 CmLList *ricSubsNode = NULLP;
10051 RanFunction *ranFuncDb = NULLP;
10052 RicSubscription *ricSubsDb = NULLP;
10053 RICsubscriptionModificationRequest_t *ricSubsModifyReq = NULLP;
10054 RICsubscriptionModificationRequest_IEs_t *ricSubsModifyReqIe = NULLP;
10056 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Request", __func__);
10061 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
10065 if(!e2apMsg->choice.initiatingMessage)
10067 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
10071 ricSubsModifyReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
10072 for(ieIdx = 0; ieIdx < ricSubsModifyReq->protocolIEs.list.count; ieIdx++)
10074 if(!ricSubsModifyReq->protocolIEs.list.array[ieIdx])
10076 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
10080 ricSubsModifyReqIe = ricSubsModifyReq->protocolIEs.list.array[ieIdx];
10081 switch(ricSubsModifyReqIe->id)
10083 case ProtocolIE_IDE2_id_RICrequestID:
10085 memset(&ricReqId, 0, sizeof(RicRequestId));
10086 ricReqId.requestorId = ricSubsModifyReqIe->value.choice.RICrequestID.ricRequestorID;
10087 ricReqId.instanceId = ricSubsModifyReqIe->value.choice.RICrequestID.ricInstanceID;
10091 case ProtocolIE_IDE2_id_RANfunctionID:
10093 ranFuncId = ricSubsModifyReqIe->value.choice.RANfunctionID;
10094 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
10097 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
10098 procFailure = true;
10102 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
10105 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
10106 __func__, ricReqId.requestorId, ricReqId.instanceId);
10107 procFailure = true;
10110 memset(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp], 0, sizeof(PendingSubsModRspInfo));
10111 memcpy(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].requestId,
10112 &ricReqId, sizeof(RicRequestId));
10113 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].ranFuncId = ranFuncId;
10117 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
10119 if(extractRicActionToBeRemovedForModification(ranFuncDb, ricSubsDb,\
10120 &ricSubsModifyReqIe->value.choice.RICactions_ToBeRemovedForModification_List,\
10121 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10123 removeActionIeProcessed= true;
10128 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
10130 if(extractRicActionToBeModifiedForModification(ranFuncDb, ricSubsDb,\
10131 &ricSubsModifyReqIe->value.choice.RICactions_ToBeModifiedForModification_List,\
10132 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10134 modActionIeProcessed = true;
10138 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
10140 if(extractRicActionToBeAddedForModification(ranFuncDb, ricSubsDb,\
10141 &ricSubsModifyReqIe->value.choice.RICactions_ToBeAddedForModification_List,\
10142 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10144 addActionIeProcessed = true;
10150 } /* End of switch for Protocol IE Id */
10154 } /* End of for loop for Protocol IE list */
10159 if(!removeActionIeProcessed && !addActionIeProcessed && !modActionIeProcessed)
10161 BuildAndSendRicSubscriptionModificationFailure(ranFuncId, ricReqId, failureCause);
10165 if(duChkTmr((PTR)ricSubsDb, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR) == true)
10167 duStopTmr((PTR)ricSubsDb, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR);
10170 ricSubsDb->action = CONFIG_MOD;
10171 ranFuncDb->numPendingSubsModRsp++;
10173 /*If the remove-action ie is present, send a stats delete request;
10174 * otherwise, change removeActionCompleted to true in the pendingSubsModRspInfo. */
10175 if(removeActionIeProcessed)
10177 BuildAndSendStatsDeleteReq(ricSubsDb, false);
10181 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].removeActionCompleted = true;
10184 /*If the mod-action ie is present, send a stats modification request;
10185 * otherwise, change modActionCompleted to true in the pendingSubsModRspInfo. */
10186 if(modActionIeProcessed)
10188 BuildAndSendStatsModificationReq(ricSubsDb);
10192 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].modActionCompleted= true;
10195 /*If the add-action ie is present, send a stats add request;
10196 * otherwise, change addActionCompleted to true in the pendingSubsModRspInfo. */
10197 if(addActionIeProcessed)
10199 BuildAndSendStatsReq(ricSubsDb);
10203 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].addActionCompleted= true;
10208 freeAperDecodingOfRicSubsModificationReq(e2apMsg);
10211 /*******************************************************************
10212 * @brief Free RIC Subscription Modification Failure Message
10216 * Function : FreeRicSubscriptionModificationFailure
10218 * Functionality: Free RIC Subscription Modification Failure
10220 * @param E2AP Message PDU
10223 ******************************************************************/
10224 void FreeRicSubscriptionModificationFailure(E2AP_PDU_t *e2apMsg)
10227 RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
10231 if(e2apMsg->choice.unsuccessfulOutcome)
10233 ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
10234 if(ricSubsModFailure->protocolIEs.list.array)
10236 for(ieIdx = 0; ieIdx < ricSubsModFailure->protocolIEs.list.count; ieIdx++)
10238 DU_FREE(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
10240 DU_FREE(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
10242 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
10244 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
10247 /*******************************************************************
10249 * @brief Builds and Send RIC Subscription Modification Failure
10253 * Function : BuildAndSendRicSubscriptionModificationFailure
10255 * Functionality: Build and send RIC Subscription Modification Failure.
10261 * @return ROK - success
10262 * RFAILED - failure
10264 ******************************************************************/
10265 uint8_t BuildAndSendRicSubscriptionModificationFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
10267 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
10268 E2AP_PDU_t *e2apMsg = NULLP;
10269 RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
10270 RICsubscriptionModificationFailure_IEs_t *ricSubsModFailureIe = NULLP;
10271 asn_enc_rval_t encRetVal; /* Encoder return value */
10275 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Failure Message\n");
10277 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
10278 if(e2apMsg == NULLP)
10280 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10284 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
10285 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
10286 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
10288 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10291 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
10292 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
10293 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure;
10296 ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
10299 ricSubsModFailure->protocolIEs.list.count = elementCnt;
10300 ricSubsModFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationFailure_IEs_t *);
10302 DU_ALLOC(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
10303 if(ricSubsModFailure->protocolIEs.list.array == NULLP)
10305 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
10309 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
10311 DU_ALLOC(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
10312 if(ricSubsModFailure->protocolIEs.list.array[ieIdx] == NULLP)
10314 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
10315 __func__, ieIdx, __LINE__);
10319 if(ieIdx < elementCnt)
10323 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10324 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
10325 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10326 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RICrequestID;
10327 ricSubsModFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
10328 ricSubsModFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
10331 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10332 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
10333 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10334 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RANfunctionID;
10335 ricSubsModFailureIe->value.choice.RANfunctionID = ranFuncId;
10338 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10339 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
10340 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10341 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_CauseE2;
10342 fillE2Cause(&ricSubsModFailureIe->value.choice.CauseE2, failureCause);
10344 /* Prints the Msg formed */
10345 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
10346 memset(encBuf, 0, ENC_BUF_MAX_LEN);
10348 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
10349 if(encRetVal.encoded == ENCODE_FAIL)
10351 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Failure Message (at %s)\n",\
10352 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10357 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Failure Message \n");
10358 #ifdef DEBUG_ASN_PRINT
10359 for(int i=0; i< encBufSize; i++)
10361 printf("%x",encBuf[i]);
10366 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
10368 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Failure Message");
10376 FreeRicSubscriptionModificationFailure(e2apMsg);
10380 /*******************************************************************
10381 * @brief Free RIC Subscription Modification Response Message
10385 * Function : FreeRicSubscriptionModificationResponse
10387 * Functionality: Free RIC Subscription Modification Response
10389 * @param E2AP Message PDU
10392 ******************************************************************/
10393 void FreeRicSubscriptionModificationResponse(E2AP_PDU_t *e2apMsg)
10395 uint8_t ieIdx = 0, elementIdx=0;
10396 RICactions_AddedForModification_List_t *actionsAdded = NULLP;
10397 RICactions_RemovedForModification_List_t *actionsRemoved = NULLP;
10398 RICactions_ModifiedForModification_List_t *actionsModified = NULLP;
10399 RICactions_FailedToBeAddedForModification_List_t *actionsFailedToBeAdded = NULLP;
10400 RICactions_FailedToBeRemovedForModification_List_t *actionsFailedToBeRemoved = NULLP;
10401 RICactions_FailedToBeModifiedForModification_List_t *actionsFailedToBeModified = NULLP;
10403 RICsubscriptionModificationResponse_t *ricSubsModResponse = NULLP;
10407 if(e2apMsg->choice.successfulOutcome)
10409 ricSubsModResponse = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse;
10410 if(ricSubsModResponse->protocolIEs.list.array)
10412 for(ieIdx = 0; ieIdx < ricSubsModResponse->protocolIEs.list.count; ieIdx++)
10414 if(ricSubsModResponse->protocolIEs.list.array[ieIdx])
10416 switch(ricSubsModResponse->protocolIEs.list.array[ieIdx]->id)
10418 case ProtocolIE_IDE2_id_RANfunctionID:
10419 case ProtocolIE_IDE2_id_RICrequestID:
10421 case ProtocolIE_IDE2_id_RICactionsRemovedForModification_List:
10423 actionsRemoved = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_RemovedForModification_List;
10424 if(actionsRemoved->list.array)
10426 for(elementIdx = 0; elementIdx < actionsRemoved->list.count; elementIdx++)
10428 DU_FREE(actionsRemoved->list.array[elementIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t));
10430 DU_FREE(actionsRemoved->list.array, actionsRemoved->list.size);
10435 case ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List:
10437 actionsFailedToBeRemoved = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeRemovedForModification_List;
10438 if(actionsFailedToBeRemoved->list.array)
10440 for(elementIdx = 0; elementIdx < actionsFailedToBeRemoved->list.count; elementIdx++)
10442 DU_FREE(actionsFailedToBeRemoved->list.array[elementIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t));
10444 DU_FREE(actionsFailedToBeRemoved->list.array, actionsFailedToBeRemoved->list.size);
10448 case ProtocolIE_IDE2_id_RICactionsModifiedForModification_List:
10450 actionsModified = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_ModifiedForModification_List;
10451 if(actionsModified->list.array)
10453 for(elementIdx = 0; elementIdx < actionsModified->list.count; elementIdx++)
10455 DU_FREE(actionsModified->list.array[elementIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t));
10457 DU_FREE(actionsModified->list.array, actionsModified->list.size);
10461 case ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List:
10463 actionsFailedToBeModified = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeModifiedForModification_List;
10464 if(actionsFailedToBeModified->list.array)
10466 for(elementIdx = 0; elementIdx < actionsFailedToBeModified->list.count; elementIdx++)
10468 DU_FREE(actionsFailedToBeModified->list.array[elementIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t));
10470 DU_FREE(actionsFailedToBeModified->list.array, actionsFailedToBeModified->list.size);
10474 case ProtocolIE_IDE2_id_RICactionsAddedForModification_List:
10476 actionsAdded = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_AddedForModification_List;
10477 if(actionsAdded->list.array)
10479 for(elementIdx = 0; elementIdx < actionsAdded->list.count; elementIdx++)
10481 DU_FREE(actionsAdded->list.array[elementIdx], sizeof(RICaction_AddedForModification_ItemIEs_t));
10483 DU_FREE(actionsAdded->list.array, actionsAdded->list.size);
10487 case ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List:
10489 actionsFailedToBeAdded = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeAddedForModification_List;
10490 if(actionsFailedToBeAdded->list.array)
10492 for(elementIdx = 0; elementIdx < actionsFailedToBeAdded->list.count; elementIdx++)
10494 DU_FREE(actionsFailedToBeAdded->list.array[elementIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t));
10496 DU_FREE(actionsFailedToBeAdded->list.array, actionsFailedToBeAdded->list.size);
10501 DU_FREE(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t));
10504 DU_FREE(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size);
10506 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
10508 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
10512 /*******************************************************************
10514 * @brief Build Ric subscription action removed list
10518 * Function : BuildActionRemovedList
10520 * Functionality: Build Ric subs action removed list
10523 * RICactions_RemovedForModification_List_t to be filled
10524 * Num Of Action removed
10525 * Action removed list
10527 * @return ROK - success
10528 * RFAILED - failure
10530 ******************************************************************/
10532 uint8_t BuildActionRemovedList(RICactions_RemovedForModification_List_t *removedActionList, uint8_t numOfActionRemoved, uint8_t *actionRemoved)
10535 RICaction_RemovedForModification_ItemIEs_t *removedActionItemIe =NULLP;
10537 removedActionList->list.count = numOfActionRemoved;
10538 removedActionList->list.size = removedActionList->list.count * sizeof(RICaction_RemovedForModification_ItemIEs_t*);
10539 DU_ALLOC(removedActionList->list.array, removedActionList->list.size);
10540 if(!removedActionList->list.array)
10542 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10546 for(arrIdx = 0; arrIdx< removedActionList->list.count; arrIdx++)
10548 DU_ALLOC(removedActionList->list.array[arrIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t));
10549 if(!removedActionList->list.array[arrIdx])
10551 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10554 removedActionItemIe = (RICaction_RemovedForModification_ItemIEs_t*)removedActionList->list.array[arrIdx];
10555 removedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_RemovedForModification_Item;
10556 removedActionItemIe->criticality = CriticalityE2_ignore;
10557 removedActionItemIe->value.present = RICaction_RemovedForModification_ItemIEs__value_PR_RICaction_RemovedForModification_Item;
10558 removedActionItemIe->value.choice.RICaction_RemovedForModification_Item.ricActionID = actionRemoved[arrIdx];
10563 /*******************************************************************
10565 * @brief Build Ric subscription action added list
10569 * Function : BuildActionAddedList
10571 * Functionality: Build Ric subs action added list
10574 * RICactions_AddedForModification_List_t to be filled
10575 * Num Of Action added
10576 * Action added list
10578 * @return ROK - success
10579 * RFAILED - failure
10581 ******************************************************************/
10583 uint8_t BuildActionAddedList(RICactions_AddedForModification_List_t *addedActionList, uint8_t numOfActionAdded, uint8_t *actionAdded)
10586 RICaction_AddedForModification_ItemIEs_t *addedActionItemIe =NULLP;
10588 addedActionList->list.count = numOfActionAdded;
10589 addedActionList->list.size = addedActionList->list.count * sizeof(RICaction_AddedForModification_ItemIEs_t*);
10590 DU_ALLOC(addedActionList->list.array, addedActionList->list.size);
10591 if(!addedActionList->list.array)
10593 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10597 for(arrIdx = 0; arrIdx< addedActionList->list.count; arrIdx++)
10599 DU_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_AddedForModification_ItemIEs_t));
10600 if(!addedActionList->list.array[arrIdx])
10602 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10605 addedActionItemIe = (RICaction_AddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx];
10606 addedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_AddedForModification_Item;
10607 addedActionItemIe->criticality = CriticalityE2_ignore;
10608 addedActionItemIe->value.present = RICaction_AddedForModification_ItemIEs__value_PR_RICaction_AddedForModification_Item;
10609 addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID = actionAdded[arrIdx];
10614 /*******************************************************************
10616 * @brief Build Ric subscription action modified list
10620 * Function : BuildActionModifiedList
10622 * Functionality: Build Ric subs action modified list
10625 * RICactions_ModifiedForModification_List_t to be filled
10626 * Num Of Action modified
10627 * Action modified list
10629 * @return ROK - success
10630 * RFAILED - failure
10632 ******************************************************************/
10634 uint8_t BuildActionModifiedList(RICactions_ModifiedForModification_List_t *modifiedActionList, uint8_t numOfActionModified, uint8_t *actionModified)
10637 RICaction_ModifiedForModification_ItemIEs_t *modifiedActionItemIe =NULLP;
10639 modifiedActionList->list.count = numOfActionModified;
10640 modifiedActionList->list.size = modifiedActionList->list.count * sizeof(RICaction_ModifiedForModification_ItemIEs_t*);
10641 DU_ALLOC(modifiedActionList->list.array, modifiedActionList->list.size);
10642 if(!modifiedActionList->list.array)
10644 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10648 for(arrIdx = 0; arrIdx< modifiedActionList->list.count; arrIdx++)
10650 DU_ALLOC(modifiedActionList->list.array[arrIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t));
10651 if(!modifiedActionList->list.array[arrIdx])
10653 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10656 modifiedActionItemIe = (RICaction_ModifiedForModification_ItemIEs_t*)modifiedActionList->list.array[arrIdx];
10657 modifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ModifiedForModification_Item;
10658 modifiedActionItemIe->criticality = CriticalityE2_ignore;
10659 modifiedActionItemIe->value.present = RICaction_ModifiedForModification_ItemIEs__value_PR_RICaction_ModifiedForModification_Item;
10660 modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID = actionModified[arrIdx];
10665 /*******************************************************************
10667 * @brief Build Ric subscription action failed to be removed list
10671 * Function : BuildActionFailedToBeRemovedList
10673 * Functionality: Build Ric subs action failed to be removed list
10676 * RICactions_FailedToBeRemovedForModification_List_t to be filled
10677 * Num Of Action failed to be removed
10678 * Action failed to be removed list
10680 * @return ROK - success
10681 * RFAILED - failure
10683 ******************************************************************/
10685 uint8_t BuildActionFailedToBeRemovedList(RICactions_FailedToBeRemovedForModification_List_t *failedToBeRemovedActionList,\
10686 uint8_t numOfActionFailedToBeRemoved, RejectedAction *actionFailedToBeRemoved)
10689 RICaction_FailedToBeRemovedForModification_ItemIEs_t *failedToBeRemovedActionItemIe =NULLP;
10691 failedToBeRemovedActionList->list.count = numOfActionFailedToBeRemoved;
10692 failedToBeRemovedActionList->list.size = failedToBeRemovedActionList->list.count * sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t*);
10693 DU_ALLOC(failedToBeRemovedActionList->list.array, failedToBeRemovedActionList->list.size);
10694 if(!failedToBeRemovedActionList->list.array)
10696 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10700 for(arrIdx = 0; arrIdx< failedToBeRemovedActionList->list.count; arrIdx++)
10702 DU_ALLOC(failedToBeRemovedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t));
10703 if(!failedToBeRemovedActionList->list.array[arrIdx])
10705 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10708 failedToBeRemovedActionItemIe = (RICaction_FailedToBeRemovedForModification_ItemIEs_t*)failedToBeRemovedActionList->list.array[arrIdx];
10709 failedToBeRemovedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeRemovedForModification_Item;
10710 failedToBeRemovedActionItemIe->criticality = CriticalityE2_ignore;
10711 failedToBeRemovedActionItemIe->value.present = RICaction_FailedToBeRemovedForModification_ItemIEs__value_PR_RICaction_FailedToBeRemovedForModification_Item;
10712 failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID = actionFailedToBeRemoved[arrIdx].id;
10713 fillE2Cause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause, actionFailedToBeRemoved[arrIdx].failureCause);
10718 /*******************************************************************
10720 * @brief Build Ric subscription action failed to be modified list
10724 * Function : BuildActionFailedToBeModifiedList
10726 * Functionality: Build Ric subs action failed to be modified list
10729 * RICactions_FailedToBeModifiedForModification_List_t to be filled
10730 * Num Of Action failed to be modified
10731 * Action failed to be modified list
10733 * @return ROK - success
10734 * RFAILED - failure
10736 ******************************************************************/
10738 uint8_t BuildActionFailedToBeModifiedList(RICactions_FailedToBeModifiedForModification_List_t *failedToBeModifiedActionList,\
10739 uint8_t numOfActionFailedToBeModified, RejectedAction *actionFailedToBeModified)
10742 RICaction_FailedToBeModifiedForModification_ItemIEs_t *failedToBeModifiedActionItemIe =NULLP;
10744 failedToBeModifiedActionList->list.count = numOfActionFailedToBeModified;
10745 failedToBeModifiedActionList->list.size = failedToBeModifiedActionList->list.count * sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t*);
10746 DU_ALLOC(failedToBeModifiedActionList->list.array, failedToBeModifiedActionList->list.size);
10747 if(!failedToBeModifiedActionList->list.array)
10749 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10753 for(arrIdx = 0; arrIdx< failedToBeModifiedActionList->list.count; arrIdx++)
10755 DU_ALLOC(failedToBeModifiedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t));
10756 if(!failedToBeModifiedActionList->list.array[arrIdx])
10758 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10761 failedToBeModifiedActionItemIe = (RICaction_FailedToBeModifiedForModification_ItemIEs_t*)failedToBeModifiedActionList->list.array[arrIdx];
10762 failedToBeModifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeModifiedForModification_Item;
10763 failedToBeModifiedActionItemIe->criticality = CriticalityE2_ignore;
10764 failedToBeModifiedActionItemIe->value.present = RICaction_FailedToBeModifiedForModification_ItemIEs__value_PR_RICaction_FailedToBeModifiedForModification_Item;
10765 failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID = actionFailedToBeModified[arrIdx].id;
10766 fillE2Cause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause, actionFailedToBeModified[arrIdx].failureCause);
10771 /*******************************************************************
10773 * @brief Build Ric subscription action failed to be added list
10777 * Function : BuildActionFailedToBeAddedList
10779 * Functionality: Build Ric subs action failed to be added list
10782 * RICactions_FailedToBeAddedForModification_List_t to be filled
10783 * Num Of Action failed to be added
10784 * Action failed to be added list
10786 * @return ROK - success
10787 * RFAILED - failure
10789 ******************************************************************/
10791 uint8_t BuildActionFailedToBeAddedList(RICactions_FailedToBeAddedForModification_List_t *failedToBeAddedActionList, uint8_t numOfActionFailedToBeAdded, RejectedAction *actionFailedToBeAdded)
10794 RICaction_FailedToBeAddedForModification_ItemIEs_t *failedToBeAddedActionItemIe =NULLP;
10796 failedToBeAddedActionList->list.count = numOfActionFailedToBeAdded;
10797 failedToBeAddedActionList->list.size = failedToBeAddedActionList->list.count * sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t*);
10798 DU_ALLOC(failedToBeAddedActionList->list.array, failedToBeAddedActionList->list.size);
10799 if(!failedToBeAddedActionList->list.array)
10801 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10805 for(arrIdx = 0; arrIdx< failedToBeAddedActionList->list.count; arrIdx++)
10807 DU_ALLOC(failedToBeAddedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t));
10808 if(!failedToBeAddedActionList->list.array[arrIdx])
10810 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10813 failedToBeAddedActionItemIe = (RICaction_FailedToBeAddedForModification_ItemIEs_t*)failedToBeAddedActionList->list.array[arrIdx];
10814 failedToBeAddedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeAddedForModification_Item;
10815 failedToBeAddedActionItemIe->criticality = CriticalityE2_ignore;
10816 failedToBeAddedActionItemIe->value.present = RICaction_FailedToBeAddedForModification_ItemIEs__value_PR_RICaction_FailedToBeAddedForModification_Item;
10817 failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.ricActionID = actionFailedToBeAdded[arrIdx].id;
10818 fillE2Cause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause, actionFailedToBeAdded[arrIdx].failureCause);
10823 /*******************************************************************
10825 * @brief Builds and Send RIC Subscription Modification Response
10829 * Function : BuildAndSendRicSubscriptionModificationResponse
10831 * Functionality: Build and send RIC Subscription Modification Response.
10834 * PendingSubsModRspInfo
10835 * @return ROK - success
10836 * RFAILED - failure
10838 ******************************************************************/
10839 uint8_t BuildAndSendRicSubscriptionModificationResponse(PendingSubsModRspInfo *pendingSubsModRsp)
10841 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
10842 E2AP_PDU_t *e2apMsg = NULLP;
10843 RICsubscriptionModificationResponse_t *ricSubsModResponse = NULLP;
10844 RICsubscriptionModificationResponse_IEs_t *ricSubsModResponseIe = NULLP;
10845 asn_enc_rval_t encRetVal; /* Encoder return value */
10849 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Response Message\n");
10851 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
10852 if(e2apMsg == NULLP)
10854 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10858 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
10859 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
10860 if(e2apMsg->choice.successfulOutcome == NULLP)
10862 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10865 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
10866 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
10867 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationResponse;
10870 ricSubsModResponse = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse;
10873 if(pendingSubsModRsp->removeActionStatus.numOfAcceptedActions)
10875 if(pendingSubsModRsp->addActionStatus.numOfAcceptedActions)
10877 if(pendingSubsModRsp->modActionStatus.numOfAcceptedActions)
10879 if(pendingSubsModRsp->removeActionStatus.numOfRejectedActions)
10881 if(pendingSubsModRsp->addActionStatus.numOfRejectedActions)
10883 if(pendingSubsModRsp->modActionStatus.numOfRejectedActions)
10886 ricSubsModResponse->protocolIEs.list.count = elementCnt;
10887 ricSubsModResponse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationResponse_IEs_t *);
10889 DU_ALLOC(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size);
10890 if(ricSubsModResponse->protocolIEs.list.array == NULLP)
10892 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10896 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
10898 DU_ALLOC(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t));
10899 if(ricSubsModResponse->protocolIEs.list.array[ieIdx] == NULLP)
10901 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
10905 if(ieIdx < elementCnt)
10909 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10910 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICrequestID;
10911 ricSubsModResponseIe->criticality = CriticalityE2_reject;
10912 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICrequestID;
10913 ricSubsModResponseIe->value.choice.RICrequestID.ricRequestorID= pendingSubsModRsp->requestId.requestorId;
10914 ricSubsModResponseIe->value.choice.RICrequestID.ricInstanceID = pendingSubsModRsp->requestId.instanceId;
10917 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10918 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RANfunctionID;
10919 ricSubsModResponseIe->criticality = CriticalityE2_reject;
10920 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RANfunctionID;
10921 ricSubsModResponseIe->value.choice.RANfunctionID = pendingSubsModRsp->ranFuncId;
10923 if(pendingSubsModRsp->removeActionStatus.numOfAcceptedActions)
10926 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10927 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsRemovedForModification_List;
10928 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10929 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_RemovedForModification_List;
10930 if(BuildActionRemovedList(&ricSubsModResponseIe->value.choice.RICactions_RemovedForModification_List,\
10931 pendingSubsModRsp->removeActionStatus.numOfAcceptedActions, pendingSubsModRsp->removeActionStatus.acceptedActionList) != ROK)
10933 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10938 if(pendingSubsModRsp->removeActionStatus.numOfRejectedActions)
10941 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10942 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List;
10943 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10944 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeRemovedForModification_List;
10945 if(BuildActionFailedToBeRemovedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeRemovedForModification_List,\
10946 pendingSubsModRsp->removeActionStatus.numOfRejectedActions, pendingSubsModRsp->removeActionStatus.rejectedActionList) != ROK)
10948 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10953 if(pendingSubsModRsp->modActionStatus.numOfAcceptedActions)
10956 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10957 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsModifiedForModification_List;
10958 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10959 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_ModifiedForModification_List;
10960 if(BuildActionModifiedList(&ricSubsModResponseIe->value.choice.RICactions_ModifiedForModification_List,\
10961 pendingSubsModRsp->modActionStatus.numOfAcceptedActions, pendingSubsModRsp->modActionStatus.acceptedActionList) != ROK)
10963 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10968 if(pendingSubsModRsp->modActionStatus.numOfRejectedActions)
10971 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10972 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List;
10973 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10974 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeModifiedForModification_List;
10975 if(BuildActionFailedToBeModifiedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeModifiedForModification_List,\
10976 pendingSubsModRsp->modActionStatus.numOfRejectedActions, pendingSubsModRsp->modActionStatus.rejectedActionList) != ROK)
10978 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10983 if(pendingSubsModRsp->addActionStatus.numOfAcceptedActions)
10986 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
10987 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsAddedForModification_List;
10988 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
10989 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_AddedForModification_List;
10990 if(BuildActionAddedList(&ricSubsModResponseIe->value.choice.RICactions_AddedForModification_List,\
10991 pendingSubsModRsp->addActionStatus.numOfAcceptedActions, pendingSubsModRsp->addActionStatus.acceptedActionList) != ROK)
10993 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
10998 if(pendingSubsModRsp->addActionStatus.numOfRejectedActions)
11001 ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
11002 ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List;
11003 ricSubsModResponseIe->criticality = CriticalityE2_ignore;
11004 ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeAddedForModification_List;
11005 if(BuildActionFailedToBeAddedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeAddedForModification_List,\
11006 pendingSubsModRsp->addActionStatus.numOfRejectedActions, pendingSubsModRsp->addActionStatus.rejectedActionList) != ROK)
11008 DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
11013 /* Prints the Msg formed */
11014 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
11015 memset(encBuf, 0, ENC_BUF_MAX_LEN);
11017 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
11018 if(encRetVal.encoded == ENCODE_FAIL)
11020 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Response Message (at %s)\n",\
11021 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11026 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Response Message \n");
11027 #ifdef DEBUG_ASN_PRINT
11028 for(int i=0; i< encBufSize; i++)
11030 printf("%x",encBuf[i]);
11035 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
11037 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Response Message");
11045 FreeRicSubscriptionModificationResponse(e2apMsg);
11049 /*******************************************************************
11051 * @brief Handles received E2AP message and sends back response
11055 * Function : E2APMsgHdlr
11058 * - Decodes received E2AP control message
11059 * - Prepares response message, encodes and sends to SCTP
11062 * @return ROK - success
11063 * RFAILED - failure
11065 * ****************************************************************/
11066 void E2APMsgHdlr(Buffer *mBuf)
11069 char *recvBuf = NULLP;
11071 MsgLen recvBufLen =0;
11072 E2AP_PDU_t *e2apMsg = NULLP;
11073 asn_dec_rval_t rval ={0}; /* Decoder return value */
11074 E2AP_PDU_t e2apasnmsg={0} ;
11076 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
11077 ODU_PRINT_MSG(mBuf, 0,0);
11079 /* Copy mBuf into char array to decode it */
11080 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
11081 DU_ALLOC(recvBuf, (Size)recvBufLen);
11083 if(recvBuf == NULLP)
11085 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
11088 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
11090 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
11094 #ifdef DEBUG_ASN_PRINT
11095 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
11096 for(i=0; i< recvBufLen; i++)
11098 printf("%x",recvBuf[i]);
11102 /* Decoding flat buffer into E2AP messsage */
11103 e2apMsg = &e2apasnmsg;
11104 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
11106 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
11107 DU_FREE(recvBuf, (Size)recvBufLen);
11109 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11111 DU_LOG("\nERROR --> E2AP : ASN decode failed");
11115 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
11117 switch(e2apMsg->present)
11119 case E2AP_PDU_PR_unsuccessfulOutcome:
11121 switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
11123 case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
11125 procE2SetupFailure(e2apMsg);
11128 case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure:
11130 procE2NodeConfigUpdateFailure(e2apMsg);
11133 case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure:
11135 procRicServiceUpdateFailure(e2apMsg);
11138 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse:
11140 procRicSubscriptionModificationRefuse(e2apMsg);
11143 case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
11145 ProcE2RemovalFailure(e2apMsg);
11150 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
11151 e2apMsg->choice.unsuccessfulOutcome->value.present);
11155 free(e2apMsg->choice.unsuccessfulOutcome);
11158 case E2AP_PDU_PR_successfulOutcome:
11160 switch(e2apMsg->choice.successfulOutcome->value.present)
11162 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
11166 procE2SetupRsp(e2apMsg);
11170 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
11172 procResetResponse(e2apMsg);
11175 case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge:
11177 procRicServiceUpdateAck(e2apMsg);
11180 case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm:
11182 procRicSubscriptionModificationConfirm(e2apMsg);
11185 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
11187 procE2NodeConfigUpdateAck(e2apMsg);
11190 case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
11192 ProcE2RemovalResponse(e2apMsg);
11197 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
11198 e2apMsg->choice.successfulOutcome->value.present);
11201 }/* End of switch(successfulOutcome) */
11202 free(e2apMsg->choice.successfulOutcome);
11206 case E2AP_PDU_PR_initiatingMessage:
11208 switch(e2apMsg->choice.initiatingMessage->value.present)
11210 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
11212 procRicSubscriptionRequest(e2apMsg);
11215 case InitiatingMessageE2__value_PR_RICserviceQuery:
11217 procRicServiceQuery(e2apMsg);
11220 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
11222 DU_LOG("\nINFO --> E2AP : Error indication received");
11225 case InitiatingMessageE2__value_PR_ResetRequestE2:
11227 DU_LOG("\nINFO --> E2AP : Reset request received");
11228 procE2ResetRequest(e2apMsg);
11231 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest:
11233 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Request received");
11234 procRicSubscriptionDeleteRequest(e2apMsg);
11237 case InitiatingMessageE2__value_PR_E2RemovalRequest:
11239 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
11240 procE2RemovalRequest(e2apMsg);
11243 case InitiatingMessageE2__value_PR_E2connectionUpdate:
11245 DU_LOG("\nINFO --> E2AP : E2 coneection update received");
11246 procE2ConnectionUpdate(e2apMsg);
11249 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest:
11251 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Request received");
11252 procRicSubscriptionModificationRequest(e2apMsg);
11257 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
11258 e2apMsg->choice.initiatingMessage->value.present);
11261 }/* End of switch(initiatingMessage) */
11262 free(e2apMsg->choice.initiatingMessage);
11267 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
11272 }/* End of switch(e2apMsg->present) */
11274 } /* End of E2APMsgHdlr */
11276 /**********************************************************************
11278 **********************************************************************/