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"
33 #include "GlobalE2node-gNB-ID.h"
34 #include "ProtocolIE-FieldE2.h"
35 #include "E2setupRequest.h"
36 #include "InitiatingMessageE2.h"
37 #include "SuccessfulOutcomeE2.h"
38 #include "UnsuccessfulOutcomeE2.h"
40 #include "odu_common_codec.h"
41 #include "E2nodeComponentInterfaceF1.h"
42 #include "E2setupRequest.h"
43 #include "du_e2_conversions.h"
44 #include "E2SM-KPM-RANfunction-Description.h"
45 #include "RANfunction-Name.h"
46 #include "RIC-EventTriggerStyle-Item.h"
47 #include "RIC-ReportStyle-Item.h"
48 #include "MeasurementInfo-Action-Item.h"
49 #include "E2SM-KPM-EventTriggerDefinition.h"
50 #include "E2SM-KPM-EventTriggerDefinition-Format1.h"
51 #include "E2SM-KPM-ActionDefinition.h"
52 #include "E2SM-KPM-ActionDefinition-Format1.h"
53 #include "MeasurementInfoItem.h"
54 #include "RANfunctionsIDcause-List.h"
55 #include "MeasurementRecord.h"
56 #include "MeasurementData.h"
57 #include "MeasurementRecordItem.h"
58 #include "MeasurementDataItem.h"
59 #include "E2SM-KPM-IndicationMessage-Format1.h"
60 #include "E2SM-KPM-IndicationMessage.h"
61 #include "E2SM-KPM-IndicationHeader.h"
62 #include "E2SM-KPM-IndicationHeader-Format1.h"
63 #include "LabelInfoItem.h"
65 /*******************************************************************
67 * @brief Fill E2 Failure Cause
71 * Function : fillE2Cause
73 * Functionality: Fill E2 Failure Cause
75 * @params[in] E2 Cause pointer to be filled in
76 * E2 Cause to be filled from
79 ******************************************************************/
80 void fillE2Cause(CauseE2_t *e2Cause, E2FailureCause failureCause)
82 e2Cause->present = failureCause.causeType;
83 switch(e2Cause->present)
85 case CauseE2_PR_ricRequest:
87 e2Cause->choice.ricRequest = failureCause.cause;
90 case CauseE2_PR_ricService:
92 e2Cause->choice.ricService = failureCause.cause;
95 case CauseE2_PR_e2Node:
97 e2Cause->choice.e2Node = failureCause.cause;
100 case CauseE2_PR_transport:
102 e2Cause->choice.transport = failureCause.cause;
105 case CauseE2_PR_protocol:
107 e2Cause->choice.protocol = failureCause.cause;
110 case CauseE2_PR_misc:
112 e2Cause->choice.misc = failureCause.cause;
115 case CauseE2_PR_NOTHING:
121 /*******************************************************************
123 * @brief Printing Type and Cause of failure
127 * Function : printE2ErrorCause
129 * Functionality: Printing Type and Cause of failure
131 * @params[in] E2 Cause
134 ******************************************************************/
135 void printE2ErrorCause(CauseE2_t *cause)
137 switch(cause->present)
139 case CauseE2_PR_ricRequest:
141 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Request", cause->choice.ricRequest);
144 case CauseE2_PR_ricService:
146 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Service", cause->choice.ricService);
149 case CauseE2_PR_e2Node:
151 DU_LOG("Failure_Type [%s] Cause [%ld]", "E2_Node", cause->choice.e2Node);
154 case CauseE2_PR_transport:
156 DU_LOG("Failure_Type [%s] Cause [%ld]", "Transport", cause->choice.transport);
159 case CauseE2_PR_protocol:
161 DU_LOG("Failure_Type [%s] Cause [%ld]", "Protocol", cause->choice.protocol);
164 case CauseE2_PR_misc:
166 DU_LOG("Failure_Type [%s] Cause [%ld]", "Miscellaneous", cause->choice.misc);
171 DU_LOG("Failure_Type and Cause unknown");
177 /*******************************************************************
179 * @brief Deallocate the memory allocated for E2 Removal Failure
183 * Function : FreeE2RemovalFailure
186 * - freeing the memory allocated for E2RemovalFailure
188 * @params[in] E2AP_PDU_t *e2apMsg
189 * @return ROK - success
192 * ****************************************************************/
193 void FreeE2RemovalFailure(E2AP_PDU_t *e2apMsg)
196 E2RemovalFailure_t *e2RemovalFailure=NULLP;
200 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
202 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
203 if(e2RemovalFailure->protocolIEs.list.array)
205 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
207 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
209 DU_FREE(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
212 DU_FREE(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
214 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
216 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
220 /*******************************************************************
222 * @brief Buld and send the E2 Removal Failure msg
226 * Function : BuildAndSendE2RemovalFailure
229 * - Buld and send the E2 Removal Failure Message
230 * @params[in] Trans Id
231 * @return ROK - success
234 * ****************************************************************/
236 uint8_t BuildAndSendRemovalFailure(uint16_t transId, E2FailureCause failureCause)
238 uint8_t ieIdx = 0, elementCnt = 0;
239 uint8_t ret = RFAILED;
240 E2AP_PDU_t *e2apMsg = NULLP;
241 E2RemovalFailure_t *e2RemovalFailure=NULLP;
242 asn_enc_rval_t encRetVal; /* Encoder return value */
244 DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
247 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
250 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
253 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
255 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
256 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
258 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
262 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
263 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
264 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure;
265 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
268 e2RemovalFailure->protocolIEs.list.count = elementCnt;
269 e2RemovalFailure->protocolIEs.list.size = elementCnt * sizeof(E2RemovalFailureIEs_t *);
270 DU_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
271 if(!e2RemovalFailure->protocolIEs.list.array)
273 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
277 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
279 DU_ALLOC(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
280 if(!e2RemovalFailure->protocolIEs.list.array[ieIdx])
282 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
286 if(ieIdx < elementCnt)
290 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
291 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
292 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = E2RemovalFailureIEs__value_PR_TransactionID;
293 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
297 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
298 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
299 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
300 fillE2Cause(&e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, failureCause);
302 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
304 memset(encBuf, 0, ENC_BUF_MAX_LEN);
306 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
307 if(encRetVal.encoded == ENCODE_FAIL)
309 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
310 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
315 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
316 for(int i=0; i< encBufSize; i++)
318 DU_LOG("%x",encBuf[i]);
323 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
325 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Failure");
333 FreeE2RemovalFailure(e2apMsg);
337 /*******************************************************************
339 * @brief Deallocate the memory allocated for E2 Removal Response
343 * Function : FreeE2RemovalResponse
346 * - freeing the memory allocated for E2RemovalResponse
348 * @params[in] E2AP_PDU_t *e2apMsg
349 * @return ROK - success
352 * ****************************************************************/
353 void FreeE2RemovalResponse(E2AP_PDU_t *e2apMsg)
356 E2RemovalResponse_t *e2RemovalResponse=NULLP;
360 if(e2apMsg->choice.successfulOutcome != NULLP)
362 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
363 if(e2RemovalResponse->protocolIEs.list.array)
365 for(ieIdx=0; ieIdx < e2RemovalResponse->protocolIEs.list.count; ieIdx++)
367 if(e2RemovalResponse->protocolIEs.list.array[ieIdx])
369 DU_FREE(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
372 DU_FREE(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
374 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
376 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
380 /*******************************************************************
382 * @brief Buld and send the E2 Removal Response msg
386 * Function : BuildAndSendE2RemovalResponse
389 * - Buld and send the E2 Removal Response Message
390 * @params[in] Trans Id
391 * @return ROK - success
394 * ****************************************************************/
395 uint8_t BuildAndSendRemovalResponse(uint16_t transId)
397 uint8_t ieIdx = 0, elementCnt = 0;
398 uint8_t ret = RFAILED;
399 E2AP_PDU_t *e2apMsg = NULLP;
400 E2RemovalResponse_t *e2RemovalResponse=NULLP;
401 asn_enc_rval_t encRetVal; /* Encoder return value */
403 DU_LOG("\nINFO --> E2AP : Building E2 Removal Response Message\n");
406 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
409 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
412 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
414 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
415 if(e2apMsg->choice.successfulOutcome == NULLP)
417 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
421 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
422 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
423 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2RemovalResponse;
424 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
427 e2RemovalResponse->protocolIEs.list.count = elementCnt;
428 e2RemovalResponse->protocolIEs.list.size = elementCnt * sizeof(E2RemovalResponseIEs_t *);
429 DU_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
430 if(!e2RemovalResponse->protocolIEs.list.array)
432 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
436 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
438 DU_ALLOC(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
439 if(!e2RemovalResponse->protocolIEs.list.array[ieIdx])
441 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
445 if(ieIdx < elementCnt)
449 e2RemovalResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
450 e2RemovalResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
451 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.present = E2RemovalResponseIEs__value_PR_TransactionID;
452 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
454 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
456 memset(encBuf, 0, ENC_BUF_MAX_LEN);
458 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
459 if(encRetVal.encoded == ENCODE_FAIL)
461 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
462 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
467 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
468 for(int i=0; i< encBufSize; i++)
470 DU_LOG("%x",encBuf[i]);
475 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
477 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Response");
485 FreeE2RemovalResponse(e2apMsg);
489 /******************************************************************
491 * @brief Deallocation of memory allocated by aper decoder for Removal req
495 * Function : freeAperDecodingOfE2RemovalReq
497 * Functionality: Deallocation of memory allocated by aper decoder for
500 * @params[in] Pointer to removalReq
503 * ****************************************************************/
504 void freeAperDecodingOfE2RemovalReq(E2RemovalRequest_t *removalReq)
510 if(removalReq->protocolIEs.list.array)
512 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
514 if(removalReq->protocolIEs.list.array[arrIdx])
516 free(removalReq->protocolIEs.list.array[arrIdx]);
519 free(removalReq->protocolIEs.list.array);
524 /*******************************************************************
526 * @brief Process Removal req received from RIC
530 * Function : procE2RemovalRequest
532 * Functionality: Process Removal req received from RIC
534 * @param E2AP_PDU_t *e2apMsg
537 ******************************************************************/
539 void procE2RemovalRequest(E2AP_PDU_t *e2apMsg)
543 E2FailureCause failureCause;
544 E2RemovalRequest_t *removalReq=NULLP;
546 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
547 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
549 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
551 switch(removalReq->protocolIEs.list.array[arrIdx]->id)
553 case ProtocolIE_IDE2_id_TransactionID:
555 transId = removalReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
560 DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
566 if(transId>=0 && transId<=255)
568 if(BuildAndSendRemovalResponse(transId) != ROK)
570 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
575 failureCause.causeType = E2_PROTOCOL;
576 failureCause.cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
578 if(BuildAndSendRemovalFailure(transId, failureCause) != ROK)
580 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
583 freeAperDecodingOfE2RemovalReq(removalReq);
586 /*******************************************************************
588 * @brief Free the ErrorIndication Message
592 * Function : FreeRicIndication
594 * Functionality: Free the ErrorIndication Message
597 * E2AP_PDU is to freed
600 ******************************************************************/
601 void FreeErrorIndication(E2AP_PDU_t *e2apMsg)
604 ErrorIndicationE2_t *errorIndicationMsg= NULLP;
608 if(e2apMsg->choice.initiatingMessage != NULLP)
610 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
611 if(errorIndicationMsg!= NULLP)
613 if(errorIndicationMsg->protocolIEs.list.array != NULLP)
615 for(arrIdx=0; arrIdx<errorIndicationMsg->protocolIEs.list.count; arrIdx++)
617 DU_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t));
619 DU_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size);
622 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
624 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
628 /*******************************************************************
630 * @brief Builds and Send the ErrorIndication Message
634 * Function : BuildAndSendErrorIndication
636 * Functionality:Fills the ErrorIndication Message
643 * @return ROK - success
646 ******************************************************************/
648 uint8_t BuildAndSendErrorIndication(int8_t transId, RicRequestId requestId, uint16_t ranFuncId, E2FailureCause failureCause)
650 uint8_t elementCnt =0, arrIdx=0, ret = RFAILED;
651 E2AP_PDU_t *e2apMsg = NULLP;
652 ErrorIndicationE2_t *errorIndicationMsg=NULLP;
653 asn_enc_rval_t encRetVal; /* Encoder return value */
657 DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
659 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
662 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
666 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
667 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
668 if(e2apMsg->choice.initiatingMessage == NULLP)
670 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
673 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
674 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
675 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2;
677 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
679 /* Element count is 2 for TransactionID/RICrequestID and Cause.
680 * If the RAN function id is present, the count will be increased.*/
687 errorIndicationMsg->protocolIEs.list.count = elementCnt;
688 errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*);
690 /* Initialize the E2Setup members */
691 DU_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
692 if(errorIndicationMsg->protocolIEs.list.array == NULLP)
694 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
698 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
700 DU_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
701 if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
703 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array [%d] elements in %s at line %d", arrIdx, __func__, __LINE__);
707 if(arrIdx < elementCnt)
712 if(transId >=0 && transId<=255)
715 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
716 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
717 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID;
718 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
723 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID;
724 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
725 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID;
726 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId;
727 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
732 /* RAN Function ID */
734 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID;
735 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
736 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID;
737 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId;
742 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
743 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
744 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
745 fillE2Cause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, failureCause);
747 /* Prints the Msg formed */
748 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
749 memset(encBuf, 0, ENC_BUF_MAX_LEN);
751 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
753 if(encRetVal.encoded == ENCODE_FAIL)
755 DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
756 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
761 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
762 #ifdef DEBUG_ASN_PRINT
763 for(int i=0; i< encBufSize; i++)
765 printf("%x",encBuf[i]);
770 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
772 DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
778 FreeErrorIndication(e2apMsg);
782 /******************************************************************
784 * @brief Deallocation of memory allocated by aper decoder for e2
785 * Config Update Failure
789 * Function : freeAperDecodingOfE2Node Config UpdateFailure
791 * Functionality: Deallocation of memory allocated by aper decoder
792 * for e2 Config Update Failure
794 * @params[in] E2nodeConfigurationUpdateFailure_t to be deallocated
797 * ****************************************************************/
799 void freeAperDecodingOfE2NodeConfigUpdateFailure(E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail)
805 if(e2NodeCfgUpdFail->protocolIEs.list.array)
807 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
809 if(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx])
811 free(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]);
814 free(e2NodeCfgUpdFail->protocolIEs.list.array);
819 /******************************************************************
821 * @brief Processes E2 Node Config Update Failure sent by RIC
825 * Function : procE2NodeConfigUpdateFailure
827 * Functionality: Processes E2 Node Config Update failure sent by RIC
829 * @params[in] E2AP_PDU_t ASN decoded E2AP message
830 * @return ROK - success
833 * ****************************************************************/
835 void procE2NodeConfigUpdateFailure(E2AP_PDU_t *e2apMsg)
837 uint8_t arrIdx =0, transId =0, timerValue=0;
838 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
840 DU_LOG("\nINFO --> E2AP : E2 Node Config Update failure received");
841 e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
843 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
845 switch(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->id)
847 case ProtocolIE_IDE2_id_TransactionID:
849 transId = e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
850 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
851 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
853 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
857 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
861 case ProtocolIE_IDE2_id_TimeToWaitE2:
863 timerValue = convertE2WaitTimerEnumToValue(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
864 if((duChkTmr((PTR)&(duCb.e2apDb), EVENT_E2_NODE_CONFIG_UPDATE_TMR)) == FALSE)
866 duStartTmr((PTR)&(duCb.e2apDb), EVENT_E2_NODE_CONFIG_UPDATE_TMR, timerValue);
870 DU_LOG("\nERROR --> E2AP : EVENT_E2_NODE_CONFIG_UPDATE_TMR timer is already running");
877 freeAperDecodingOfE2NodeConfigUpdateFailure(e2NodeCfgUpdFail);
880 /*******************************************************************
882 * @brief Builds Global gNodeB Params
886 * Function : BuildGlobalgNBId
888 * Functionality: Building the Plmn and gNB id
890 * @params[in] GlobalE2node_gNB_ID_t *gNbId
891 * @return ROK - success
894 ******************************************************************/
896 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
899 uint8_t byteSize = 4;
900 uint8_t gnbId = duCb.gnbId;
903 /* fill Global gNB ID Id */
904 gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
905 gNbId->global_gNB_ID.plmn_id.buf = NULLP;
906 DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
907 if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
909 DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
914 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
915 gNbId->global_gNB_ID.plmn_id.buf);
916 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
917 /* Allocate Buffer size */
918 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
919 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
920 DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
921 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
922 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
924 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
929 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId);
934 DU_ALLOC( gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
935 if(gNbId->gNB_DU_ID == NULLP)
937 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID ");
942 gNbId->gNB_DU_ID->size = sizeof(uint8_t);
943 DU_ALLOC( gNbId->gNB_DU_ID->buf, sizeof(uint8_t));
944 if(gNbId->gNB_DU_ID->buf)
946 gNbId->gNB_DU_ID->buf[0] =duCb.e2apDb.e2NodeId;
950 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID buffer");
958 /*******************************************************************
960 * @brief fill the E2 node config information
964 * Function : fillE2NodeConfig
966 * Functionality: fill E2 node config information
969 * Pointer to e2NodeCfg to be filled
970 * E2 Node Component information
971 * Type of configuration
972 * @return ROK - success
975 ******************************************************************/
977 uint8_t fillE2NodeConfig(PTR e2NodeCfg, E2NodeComponent *e2NodeComponentInfo, ConfigType configType)
979 E2NodeConfig *e2NodeConfig=NULLP;
980 E2nodeComponentInterfaceType_t *interfaceType=NULLP;
981 E2nodeComponentID_t *componentID =NULLP;
982 E2nodeComponentConfiguration_t *configuration=NULLP;
983 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
984 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULL;
985 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
991 e2NodeAddItem = (E2nodeComponentConfigAddition_Item_t*)e2NodeCfg;
992 interfaceType = &e2NodeAddItem->e2nodeComponentInterfaceType;
993 componentID = &e2NodeAddItem->e2nodeComponentID;
994 configuration = &e2NodeAddItem->e2nodeComponentConfiguration;
995 e2NodeConfig = e2NodeComponentInfo->addConfiguration;
1000 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_Item_t *) e2NodeCfg;
1001 interfaceType = &e2NodeUpdateItem->e2nodeComponentInterfaceType;
1002 componentID = &e2NodeUpdateItem->e2nodeComponentID;
1003 configuration = &e2NodeUpdateItem->e2nodeComponentConfiguration;
1004 e2NodeConfig = e2NodeComponentInfo->updateConfiguration;
1009 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_Item_t*) e2NodeCfg;
1010 interfaceType = &e2NodeRemovalItem->e2nodeComponentInterfaceType;
1011 componentID = &e2NodeRemovalItem->e2nodeComponentID;
1016 DU_LOG("\nERROR --> E2AP : Configuration type %d does not supported ", configType);
1020 /* E2nodeComponentInterfaceType */
1021 *interfaceType = convertInterfaceToE2ComponentInterfaceType(e2NodeComponentInfo->interfaceType);
1023 /* We now only support the F1 interface out of these interfaces
1024 * (NG,XN,E1,F1,W1,S1,X2), therefore only the F1 component identifier was filled in. */
1026 if(*interfaceType == F1)
1028 /* E2 Node Component ID */
1029 componentID->present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
1030 DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1,sizeof(E2nodeComponentInterfaceF1_t));
1031 if(componentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
1033 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1036 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
1037 DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
1038 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1040 if(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
1042 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1045 memcpy(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, &e2NodeComponentInfo->componentId,\
1046 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1049 if(configType == CONFIG_DEL)
1051 /* We don't need to fill out the E2 Node Component Request and Response
1052 * information in the case of CONFIG_DEL, therefore returning ROK from here. */
1056 /* E2 Node Component Request Part */
1057 if(e2NodeConfig->componentRequestPart)
1059 configuration->e2nodeComponentRequestPart.size = e2NodeConfig->reqBufSize ;
1060 DU_ALLOC(configuration->e2nodeComponentRequestPart.buf,\
1061 configuration->e2nodeComponentRequestPart.size);
1062 if(configuration->e2nodeComponentRequestPart.buf == NULLP)
1064 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1068 memcpy(configuration->e2nodeComponentRequestPart.buf,\
1069 e2NodeConfig->componentRequestPart, configuration->\
1070 e2nodeComponentRequestPart.size);
1074 DU_LOG("\nERROR --> E2AP: componentRequestPart is null ");
1078 /* E2 Node Component Response Part */
1079 if(e2NodeConfig->componentResponsePart)
1081 configuration->e2nodeComponentResponsePart.size = e2NodeConfig->rspBufSize;
1082 DU_ALLOC(configuration->e2nodeComponentResponsePart.buf, configuration->e2nodeComponentResponsePart.size);
1083 if(configuration->e2nodeComponentResponsePart.buf == NULLP)
1085 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1088 memcpy(configuration->e2nodeComponentResponsePart.buf, e2NodeConfig->componentResponsePart, configuration->\
1089 e2nodeComponentResponsePart.size);
1093 DU_LOG("\nERROR --> E2AP: componentResponsePart is null");
1100 /*******************************************************************
1102 * @brief Builds E2 node config addition list
1106 * Function : BuildE2NodeConfigAddList
1108 * Functionality: Building E2 node config addition list
1111 * E2nodeComponentConfigAddition_List_t to be filled
1113 * Count of E2 node to be added in the list
1114 * Received list of E2 node configuration
1116 * @return ROK - success
1119 ******************************************************************/
1121 uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAddList, uint8_t procedureCode, uint16_t count, E2NodeConfigItem *e2NodeList)
1124 CmLList *node =NULL;
1125 E2NodeComponent *e2NodeComponentInfo=NULL;
1126 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe=NULL;
1127 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
1130 /* For ProcedureCodeE2_id_E2setup, the number of E2 node configuration list items is
1131 * equal to the number of E2 node configuration entries stored in the database.
1132 * For any other procedure, the E2 node configuration list count is equal
1133 * to the count of E2 node configuration obtained from the function's caller */
1135 if(procedureCode == ProcedureCodeE2_id_E2setup)
1136 e2NodeAddList->list.count = duCb.e2apDb.e2NodeComponentList.count;
1138 e2NodeAddList->list.count = count;
1140 e2NodeAddList->list.size = e2NodeAddList->list.count * sizeof(E2nodeComponentConfigAddition_ItemIEs_t *);
1141 DU_ALLOC(e2NodeAddList->list.array, e2NodeAddList->list.size);
1142 if(e2NodeAddList->list.array == NULLP)
1144 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
1148 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
1150 DU_ALLOC(e2NodeAddList->list.array[arrIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
1151 if(e2NodeAddList->list.array[arrIdx] == NULLP)
1153 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
1157 if(procedureCode == ProcedureCodeE2_id_E2setup)
1159 /* Getting all of the E2 node configuration's information from DuCb one by one*/
1162 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
1170 DU_LOG("\nERROR --> E2AP : E2 node component list node is null");
1173 e2NodeComponentInfo = (E2NodeComponent*)node->node;
1177 /* Getting only those E2 node configuration from DuCb whose interface
1178 * and action type is present in the received array */
1179 e2NodeComponentInfo = fetchE2NodeComponentInfo(e2NodeList[arrIdx].interface, e2NodeList[arrIdx].componentId, &node);
1182 if(!e2NodeComponentInfo)
1184 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1188 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
1189 e2NodeAddItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition_Item;
1190 e2NodeAddItemIe->criticality = CriticalityE2_reject;
1191 e2NodeAddItemIe->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
1192 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
1193 if(fillE2NodeConfig((PTR)e2NodeAddItem, e2NodeComponentInfo, CONFIG_ADD) != ROK)
1195 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1202 /*******************************************************************
1204 * @brief Builds E2 node config update list
1208 * Function : BuildE2NodeConfigUpdateList
1210 * Functionality: Building E2 node config update list
1213 * E2nodeComponentConfigUpdate_List_t to be filled
1214 * Count of E2 node to be update in the list
1215 * Received list of E2 node configuration
1217 * @return ROK - success
1220 ******************************************************************/
1222 uint8_t BuildE2NodeConfigUpdateList(E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList, uint16_t count, E2NodeConfigItem *updateE2Node)
1225 CmLList *node =NULL;
1226 E2NodeComponent *e2NodeComponentInfo =NULL;
1227 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe =NULL;
1228 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULL;
1230 e2NodeUpdateList->list.count = count;
1231 e2NodeUpdateList->list.size = e2NodeUpdateList->list.count * sizeof(E2nodeComponentConfigUpdate_ItemIEs_t *);
1232 DU_ALLOC(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
1233 if(e2NodeUpdateList->list.array == NULLP)
1235 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
1239 for(arrIdx = 0; arrIdx< e2NodeUpdateList->list.count; arrIdx++)
1241 DU_ALLOC(e2NodeUpdateList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
1242 if(e2NodeUpdateList->list.array[arrIdx] == NULLP)
1244 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
1248 e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface, updateE2Node[arrIdx].componentId, &node);
1249 if(!e2NodeComponentInfo)
1251 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1255 e2NodeUpdateItemIe = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[arrIdx];
1256 e2NodeUpdateItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate_Item;
1257 e2NodeUpdateItemIe->criticality = CriticalityE2_reject;
1258 e2NodeUpdateItemIe->value.present = E2nodeComponentConfigUpdate_ItemIEs__value_PR_E2nodeComponentConfigUpdate_Item;
1259 e2NodeUpdateItem = &e2NodeUpdateItemIe->value.choice.E2nodeComponentConfigUpdate_Item;
1261 if(fillE2NodeConfig((PTR)e2NodeUpdateItem, e2NodeComponentInfo, CONFIG_MOD) != ROK)
1263 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1273 /*******************************************************************
1275 * @brief Builds E2 node config remove list
1279 * Function :BuildE2NodeConfigRemoveList
1281 * Functionality: Building E2 node config remove list
1284 * E2nodeComponentConfigRemoval_List_t to be filled
1285 * Count of E2 node to be remove in the list
1286 * Received list of E2 node configuration
1287 * @return ROK - success
1290 ******************************************************************/
1292 uint8_t BuildE2NodeConfigRemoveList(E2nodeComponentConfigRemoval_List_t *e2NodeRemoveList, uint16_t count, E2NodeConfigItem *updateE2Node)
1296 E2NodeComponent *e2NodeComponentInfo=NULL;
1297 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItemIe=NULL;
1298 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
1300 e2NodeRemoveList->list.count = count;
1301 e2NodeRemoveList->list.size = e2NodeRemoveList->list.count * sizeof(E2nodeComponentConfigRemoval_ItemIEs_t *);
1302 DU_ALLOC(e2NodeRemoveList->list.array, e2NodeRemoveList->list.size);
1303 if(e2NodeRemoveList->list.array == NULLP)
1305 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
1309 for(arrIdx = 0; arrIdx< e2NodeRemoveList->list.count; arrIdx++)
1311 DU_ALLOC(e2NodeRemoveList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
1312 if(e2NodeRemoveList->list.array[arrIdx] == NULLP)
1314 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
1318 e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface,updateE2Node[arrIdx].componentId, &node);
1319 if(!e2NodeComponentInfo)
1321 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1325 e2NodeRemovalItemIe = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemoveList->list.array[arrIdx];
1326 e2NodeRemovalItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval_Item;
1327 e2NodeRemovalItemIe->criticality = CriticalityE2_reject;
1328 e2NodeRemovalItemIe->value.present = E2nodeComponentConfigRemoval_ItemIEs__value_PR_E2nodeComponentConfigRemoval_Item;
1329 e2NodeRemovalItem = &e2NodeRemovalItemIe->value.choice.E2nodeComponentConfigRemoval_Item;
1331 if(fillE2NodeConfig((PTR)e2NodeRemovalItem, e2NodeComponentInfo, CONFIG_DEL) != ROK)
1333 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1340 /*******************************************************************
1342 * @brief deallocation of E2SM_KPM_RANfunction_Description_t
1346 * Function : freeE2smKpmRanFunctionDefinition
1348 * Functionality: deallocation of E2SM_KPM_RANfunction_Description_t
1350 * @params[in] E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition
1353 ******************************************************************/
1355 void freeE2smKpmRanFunctionDefinition(E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition)
1357 MeasurementInfo_Action_Item_t *measInfoList;
1358 uint8_t eventTriggerIdx, reportStyleIdx, measInfoIdx;
1359 RANfunction_Name_t *ranFuncName;
1360 struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle;
1361 struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *eventTriggerStyle;
1362 if(ranFunctionDefinition)
1364 ranFuncName = &ranFunctionDefinition->ranFunction_Name;
1365 /* Free RAN function Name */
1366 DU_FREE(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
1367 DU_FREE(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
1368 DU_FREE(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
1370 /* Sequence of Event Trigger styles */
1371 eventTriggerStyle = ranFunctionDefinition->ric_EventTriggerStyle_List;
1372 if(eventTriggerStyle)
1374 if(eventTriggerStyle->list.array)
1376 for(eventTriggerIdx =0;eventTriggerIdx<eventTriggerStyle->list.count; eventTriggerIdx++)
1378 if(eventTriggerStyle->list.array[eventTriggerIdx])
1380 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.buf,\
1381 eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.size);
1382 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
1385 DU_FREE(eventTriggerStyle->list.array, eventTriggerStyle->list.size)
1387 DU_FREE(eventTriggerStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
1390 /* Sequence of Report styles */
1391 ricReportStyle = ranFunctionDefinition->ric_ReportStyle_List;
1394 if(ricReportStyle->list.array)
1396 for(reportStyleIdx =0;reportStyleIdx<ricReportStyle->list.count; reportStyleIdx++)
1398 if(ricReportStyle->list.array[reportStyleIdx])
1400 if(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf)
1402 DU_FREE(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf,\
1403 ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.size);
1405 if(ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array)
1407 for(measInfoIdx=0; measInfoIdx<ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.count; \
1410 measInfoList = ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array[measInfoIdx];
1413 DU_FREE(measInfoList->measID, sizeof(long));
1414 DU_FREE(measInfoList->measName.buf, measInfoList->measName.size);
1415 DU_FREE(measInfoList,sizeof(MeasurementInfo_Action_Item_t));
1418 DU_FREE(measInfoList,ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.size);
1420 DU_FREE(ricReportStyle->list.array[reportStyleIdx], sizeof(RIC_ReportStyle_Item_t));
1423 DU_FREE(ricReportStyle->list.array, ricReportStyle->list.size);
1425 DU_FREE(ricReportStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1427 DU_FREE(ranFunctionDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1431 /*******************************************************************
1433 * @brief fill the e2sm ric report style
1437 * Function : fillRicReportStyle
1439 * Functionality: fill the report style
1441 * @params[in] RanFunction *ranFuncDb, struct
1442 * E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle
1443 * @return ROK - success
1446 ******************************************************************/
1447 uint8_t fillRicReportStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle)
1449 uint8_t styleIdx, measInfoIdx;
1450 MeasurementInfo_Action_List_t *measInfo;
1453 ricReportStyle->list.count = ranFuncDb->numOfReportStyleSupported;
1454 ricReportStyle->list.size = ricReportStyle->list.count * sizeof(RIC_ReportStyle_Item_t*);
1455 DU_ALLOC(ricReportStyle->list.array, ricReportStyle->list.size);
1456 if(!ricReportStyle->list.array)
1458 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__);
1462 for(styleIdx =0;styleIdx<ricReportStyle->list.count; styleIdx++)
1464 DU_ALLOC(ricReportStyle->list.array[styleIdx], sizeof(RIC_ReportStyle_Item_t));
1465 if(!ricReportStyle->list.array[styleIdx])
1467 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1471 /* RIC Report Style Type */
1472 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType;
1474 /* RIC Report Style Format Type */
1475 ricReportStyle->list.array[styleIdx]->ric_ActionFormat_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType;
1477 /* RIC Report Style Name */
1478 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size = strlen(ranFuncDb->reportStyleList[styleIdx].reportStyle.name);
1479 DU_ALLOC(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf,\
1480 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1481 if(!ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf)
1483 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1486 memcpy(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf, ranFuncDb->reportStyleList[styleIdx].reportStyle.name,\
1487 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1489 /* RIC Indication Header Format Type*/
1490 ricReportStyle->list.array[styleIdx]->ric_IndicationHeaderFormat_Type = ranFuncDb->ricIndicationHeaderFormat;
1492 /* RIC Indication Message Format Type*/
1493 ricReportStyle->list.array[styleIdx]->ric_IndicationMessageFormat_Type = ranFuncDb->ricIndicationMessageFormat;
1495 /* Measurement Info Action List */
1496 CmLListCp measInfoList =ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
1497 if(!measInfoList.count)
1502 CM_LLIST_FIRST_NODE(&ranFuncDb->reportStyleList[styleIdx].measurementInfoList, node);
1503 measInfo = &ricReportStyle->list.array[styleIdx]->measInfo_Action_List;
1505 measInfo->list.count = measInfoList.count;
1506 measInfo->list.size = measInfoList.count*sizeof(MeasurementInfo_Action_Item_t*);
1507 DU_ALLOC(measInfo->list.array, measInfo->list.size);
1508 if(!measInfo->list.array)
1510 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1514 for(measInfoIdx=0; measInfoIdx<measInfo->list.count; measInfoIdx++)
1518 DU_LOG("\nERROR --> E2AP: Measurement info node is null");
1522 DU_ALLOC(measInfo->list.array[measInfoIdx],sizeof(MeasurementInfo_Action_Item_t));
1523 if(!measInfo->list.array[measInfoIdx])
1525 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1528 MeasurementInfoForAction *measInfoForAction= (MeasurementInfoForAction*)node->node;
1529 DU_ALLOC(measInfo->list.array[measInfoIdx]->measID, sizeof(long));
1530 if(!measInfo->list.array[measInfoIdx]->measID)
1532 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1536 memcpy(measInfo->list.array[measInfoIdx]->measID, &measInfoForAction->measurementTypeId,sizeof(long));
1537 measInfo->list.array[measInfoIdx]->measName.size= strlen(measInfoForAction->measurementTypeName);
1538 DU_ALLOC(measInfo->list.array[measInfoIdx]->measName.buf, measInfo->list.array[measInfoIdx]->measName.size);
1539 if(!measInfo->list.array[measInfoIdx]->measName.size)
1541 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1545 memcpy(measInfo->list.array[measInfoIdx]->measName.buf, \
1546 measInfoForAction->measurementTypeName,\
1547 measInfo->list.array[measInfoIdx]->measName.size);
1554 /*******************************************************************
1556 * @brief fill the ric event trigger style
1560 * Function : fillRicEventTriggerStyle
1562 * Functionality: fill the ric event trigger style
1565 * @return ROK - success
1568 ******************************************************************/
1569 uint8_t fillRicEventTriggerStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *ricEventTriggerStyle)
1573 ricEventTriggerStyle->list.count = ranFuncDb->numOfEventTriggerStyleSupported;
1574 ricEventTriggerStyle->list.size = ricEventTriggerStyle->list.count* sizeof(RIC_EventTriggerStyle_Item_t *);
1575 DU_ALLOC(ricEventTriggerStyle->list.array, ricEventTriggerStyle->list.size);
1576 if(!ricEventTriggerStyle->list.array)
1578 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__);
1582 for(styleIdx =0;styleIdx<ricEventTriggerStyle->list.count; styleIdx++)
1584 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
1585 if(!ricEventTriggerStyle->list.array[styleIdx])
1587 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1590 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Type = ranFuncDb->eventTriggerStyleList[styleIdx].styleType;
1592 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerFormat_Type = ranFuncDb->eventTriggerStyleList[styleIdx].formatType;
1594 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size = strlen(ranFuncDb->eventTriggerStyleList[styleIdx].name);
1595 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,\
1596 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1597 if(!ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf)
1599 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1602 memcpy(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,ranFuncDb->eventTriggerStyleList[styleIdx].name,\
1603 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1609 /*******************************************************************
1611 * @brief Builds Ran function item
1615 * Function : BuildRanFunctionItem
1617 * Functionality: Building RAN function item
1620 * RAN function item that has to be filled
1621 * Stored RAN Function information
1622 * @return ROK - success
1625 ******************************************************************/
1627 uint8_t BuildRanFunctionItem(RANfunction_Item_t *ranFuncItem, RanFunction *ranFuncDb)
1629 uint8_t ret =RFAILED;
1630 RANfunctionDefinition_t *ranFunctionDefinition;
1631 RANfunction_Name_t *ranFuncName;
1632 asn_enc_rval_t encRetVal;
1633 E2SM_KPM_RANfunction_Description_t *ranFuncDefinition;
1637 /* RAN function Id*/
1638 ranFuncItem->ranFunctionID = ranFuncDb->id;
1640 /* RAN Function Revision*/
1641 ranFuncItem->ranFunctionRevision = ranFuncDb->revisionCounter;
1643 /* RAN function OID*/
1644 ranFuncItem->ranFunctionOID.size = strlen(ranFuncDb->name.serviceModelOID);
1645 DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size);
1646 if(!ranFuncItem->ranFunctionOID.buf)
1648 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1651 memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size);
1653 /* RAN function Definition */
1654 DU_ALLOC(ranFuncDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1655 if(!ranFuncDefinition)
1657 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1661 /* RAN function Name */
1662 ranFuncName = &ranFuncDefinition->ranFunction_Name;
1664 /* RAN function ShortName */
1665 ranFuncName->ranFunction_ShortName.size = strlen(ranFuncDb->name.shortName);
1666 DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
1667 if(!ranFuncName->ranFunction_ShortName.buf)
1669 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1672 memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName));
1674 /* RAN function E2SM_OID */
1675 ranFuncName->ranFunction_E2SM_OID.size = strlen(ranFuncDb->name.serviceModelOID);
1676 DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
1677 if(!ranFuncName->ranFunction_E2SM_OID.buf)
1679 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1682 memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
1684 /* RAN Function Name Description */
1685 ranFuncName->ranFunction_Description.size = strlen(ranFuncDb->name.description);
1686 DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
1687 if(!ranFuncName->ranFunction_Description.buf)
1689 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1692 memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size);
1694 /* RIC Event Trigger Style List */
1695 DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
1696 if(!ranFuncDefinition->ric_EventTriggerStyle_List)
1698 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1702 if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
1704 DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
1708 /* RIC Report Style List */
1709 DU_ALLOC(ranFuncDefinition->ric_ReportStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1710 if(!ranFuncDefinition->ric_ReportStyle_List)
1712 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1715 if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
1717 DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
1721 /* Encode the F1SetupRequest type as APER */
1722 xer_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, ranFuncDefinition);
1724 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1726 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_RANfunction_Description, 0, ranFuncDefinition, PrepFinalEncBuf, encBuf);
1728 /* Encode results */
1729 if(encRetVal.encoded == ENCODE_FAIL)
1731 DU_LOG("\nERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\
1732 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1737 DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n");
1738 for(uint8_t measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
1740 printf("%x",encBuf[measIeIdx]);
1742 ranFunctionDefinition = &ranFuncItem->ranFunctionDefinition;
1743 ranFunctionDefinition->size = encBufSize;
1744 DU_ALLOC(ranFunctionDefinition->buf, encBufSize);
1745 if(ranFunctionDefinition->buf == NULLP)
1747 DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
1750 memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize);
1755 freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
1759 /*******************************************************************
1761 * @brief Builds Ran function add list based on the procedure code
1765 * Function : BuildRanFunctionAddList
1767 * Functionality: Building RAN addition addition list
1768 * In case of ProcedureCodeE2_id_E2setup we add all the RAN Function list
1769 * which is present in E2 database.
1770 * In the case of other procedures, we just fill the RAN functions whose ID
1771 * is contained in recvList
1776 * Count of ran functions to be added in the list
1777 * Received list of RAN functions
1779 * @return ROK - success
1782 ******************************************************************/
1784 uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList, uint8_t procedureCode, uint8_t count, RanFuncInfo *recvList)
1787 RanFunction *ranFuncDb;
1789 RANfunction_ItemIEs_t *ranFuncItemIe;
1791 /* For ProcedureCodeE2_id_E2setup, the number of RAN function list items is
1792 * equal to the number of ran function entries stored in the database.
1793 * For any other procedure, the RAN function list count is equal
1794 * to the count of ran functions obtained from the function's caller */
1796 if(procedureCode == ProcedureCodeE2_id_E2setup)
1797 ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
1799 ranFunctionsList->list.count = count;
1801 ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*);
1802 DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
1803 if(ranFunctionsList->list.array == NULLP)
1805 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1809 for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++)
1811 DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1812 if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
1814 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1817 if(procedureCode == ProcedureCodeE2_id_E2setup)
1819 /* Getting all of the RAN function's information from DuCb one by one*/
1820 ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
1824 /* Getting only the RAN function information from DuCb whose Id is
1825 * present in the received array */
1826 id =recvList[ranFuncIdx].id;
1827 ranFuncDb = &duCb.e2apDb.ranFunction[id-1];
1829 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1830 ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item;
1831 ranFuncItemIe->criticality = CriticalityE2_ignore;
1832 ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
1833 BuildRanFunctionItem(&ranFuncItemIe->value.choice.RANfunction_Item, ranFuncDb);
1838 /*******************************************************************
1840 * @brief De Allocate E2 Setup Request Message
1844 * Function : FreeE2SetupReq
1846 * Functionality: De-Allocating E2 Setup request Message
1848 * @params[in] E2AP_PDU_t *e2apMsg
1852 * ****************************************************************/
1854 void FreeE2SetupReq(E2AP_PDU_t *e2apMsg)
1857 uint8_t e2NodeAddListIdx =0, ranFuncAddListIdx;
1858 E2setupRequest_t *e2SetupReq;
1859 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1860 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1861 RANfunctions_List_t *ranFunctionsList;
1862 RANfunction_ItemIEs_t *ranFuncItemIe;
1863 RANfunction_Item_t *ranFunItem;
1865 /* De-allocating Memory */
1866 if(e2apMsg != NULLP)
1868 if(e2apMsg->choice.initiatingMessage != NULLP)
1870 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
1871 if(e2SetupReq->protocolIEs.list.array != NULLP)
1873 for(arrIdx = 0; arrIdx < e2SetupReq->protocolIEs.list.count; arrIdx++)
1875 if(e2SetupReq->protocolIEs.list.array[arrIdx] != NULLP)
1877 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1879 case ProtocolIE_IDE2_id_TransactionID:
1881 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1883 if(e2SetupReq->protocolIEs.list.array[arrIdx]->\
1884 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
1886 GlobalE2node_gNB_ID_t *gNbId = NULLP;
1887 gNbId = e2SetupReq->protocolIEs.list.array[arrIdx]->\
1888 value.choice.GlobalE2node_ID.choice.gNB;
1889 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
1891 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
1892 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
1893 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
1894 gNbId->global_gNB_ID.plmn_id.size);
1897 if(gNbId->gNB_DU_ID != NULLP)
1899 DU_FREE( gNbId->gNB_DU_ID->buf, gNbId->gNB_DU_ID->size);
1900 DU_FREE(gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
1902 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
1903 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
1907 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1909 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1910 if(e2NodeAddList->list.array)
1912 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1914 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
1916 /* Free E2 Node Component Request Part */
1917 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
1918 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
1920 /* Free E2 Node Component Response Part */
1921 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.\
1922 e2nodeComponentResponsePart.buf, \
1923 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
1925 /* Free E2 Node Component ID */
1926 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1)
1928 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1929 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
1930 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1931 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1932 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
1933 sizeof(E2nodeComponentInterfaceF1_t));
1935 DU_FREE(e2NodeAddList->list.array[e2NodeAddListIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
1937 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
1941 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1943 ranFunctionsList = &(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
1944 if(ranFunctionsList->list.array)
1946 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
1948 if(ranFunctionsList->list.array[ranFuncAddListIdx])
1950 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
1951 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1952 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
1953 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
1954 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
1957 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
1963 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
1964 (e2SetupReq->protocolIEs.list.array[arrIdx]->id));
1967 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx], sizeof(E2setupRequestIEs_t));
1970 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
1972 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1974 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1978 /*******************************************************************
1980 * @brief Builds and Send the E2SetupRequest
1984 * Function : BuildAndSendE2SetupReq
1986 * Functionality:Fills the E2SetupRequest
1988 * @return ROK - success
1991 ******************************************************************/
1993 uint8_t BuildAndSendE2SetupReq()
1995 uint8_t arrIdx = 0, elementCnt=0;
1996 uint8_t transId = 0, ret = RFAILED;
1997 bool memAllocFailed = false;
1998 E2AP_PDU_t *e2apMsg = NULLP;
1999 E2setupRequest_t *e2SetupReq = NULLP;
2000 asn_enc_rval_t encRetVal; /* Encoder return value */
2002 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
2005 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2006 if(e2apMsg == NULLP)
2008 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2011 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2012 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2013 if(e2apMsg->choice.initiatingMessage == NULLP)
2015 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2018 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2019 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
2020 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
2021 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
2024 e2SetupReq->protocolIEs.list.count = elementCnt;
2025 e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*);
2027 /* Initialize the E2Setup members */
2028 DU_ALLOC(e2SetupReq->protocolIEs.list.array, \
2029 e2SetupReq->protocolIEs.list.size);
2030 if(e2SetupReq->protocolIEs.list.array == NULLP)
2032 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
2035 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
2037 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx],\
2038 sizeof(E2setupRequestIEs_t));
2039 if(e2SetupReq->protocolIEs.list.array[arrIdx] == NULLP)
2041 memAllocFailed = true;
2042 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
2046 if(memAllocFailed == true)
2052 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2053 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2054 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
2055 transId = assignTransactionId();
2056 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2059 /* GlobalE2node_gNB_ID */
2060 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
2061 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2062 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
2063 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
2065 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
2066 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
2067 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
2068 GlobalE2node_ID.choice.gNB == NULLP)
2070 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
2075 ret = BuildGlobalgNBId(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
2076 choice.GlobalE2node_ID.choice.gNB);
2079 DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
2084 /* RAN Functions Added List */
2086 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
2087 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2088 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
2089 if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
2091 DU_LOG("\nERROR --> E2AP : Failed to create RAN Function");
2095 /* E2 Node Component Configuration Addition List */
2097 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
2098 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2099 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
2100 if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
2102 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
2108 /* Prints the Msg formed */
2109 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2111 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2113 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
2115 if(encRetVal.encoded == ENCODE_FAIL)
2117 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
2118 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2123 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
2124 #ifdef DEBUG_ASN_PRINT
2125 for(int i=0; i< encBufSize; i++)
2127 printf("%x",encBuf[i]);
2131 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2133 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
2138 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
2139 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
2141 FreeE2SetupReq(e2apMsg);
2143 }/* End of BuildAndSendE2SetupReq */
2145 /*******************************************************************
2147 * @brief Builds RIC Action Admitted List
2151 * Function : BuildRicActionAdmitList
2153 * Functionality: Builds RIC Action Admitted List
2155 * @params[in] Pointer to RIC Action Admitted List to be filled
2156 * Subscription Response information
2157 * @return ROK - success
2160 * ****************************************************************/
2161 uint8_t BuildRicActionAdmitList(RICaction_Admitted_List_t *admitList, PendingSubsRspInfo *subsRspInfo)
2164 uint8_t elementCnt = 0;
2165 RICaction_Admitted_ItemIEs_t *admitItem = NULLP;
2167 elementCnt = subsRspInfo->numOfAcceptedActions;
2169 admitList->list.count = elementCnt;
2170 admitList->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t *);
2172 DU_ALLOC(admitList->list.array, admitList->list.size);
2173 if(admitList->list.array == NULLP)
2175 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2179 for(idx=0; idx<elementCnt; idx++)
2181 DU_ALLOC(admitList->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
2182 if(admitList->list.array[idx] == NULLP)
2184 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2188 admitItem = (RICaction_Admitted_ItemIEs_t *)admitList->list.array[idx];
2189 admitItem->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
2190 admitItem->criticality = CriticalityE2_reject;
2191 admitItem->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
2192 admitItem->value.choice.RICaction_Admitted_Item.ricActionID = subsRspInfo->acceptedActionList[idx];
2197 /*******************************************************************
2199 * @brief Builds RIC Action Not Admitted List
2203 * Function : BuildRicActionNotAdmitList
2205 * Functionality: Builds RIC Action Not Admitted List
2207 * @params[in] Pointer to RIC Action Not Admitted List to be filled
2208 * Subscription Response information
2209 * @return ROK - success
2212 * ****************************************************************/
2213 uint8_t BuildRicActionNotAdmitList(RICaction_NotAdmitted_List_t *notAdmitList, PendingSubsRspInfo *subsRspInfo)
2216 uint8_t elementCnt = 0;
2217 RICaction_NotAdmitted_ItemIEs_t *notAdmitItem = NULLP;
2219 elementCnt = subsRspInfo->numOfRejectedActions;
2221 notAdmitList->list.count = elementCnt;
2222 notAdmitList->list.size = elementCnt * sizeof(RICaction_NotAdmitted_ItemIEs_t *);
2224 DU_ALLOC(notAdmitList->list.array, notAdmitList->list.size);
2225 if(notAdmitList->list.array == NULLP)
2227 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2231 for(idx=0; idx<elementCnt; idx++)
2233 DU_ALLOC(notAdmitList->list.array[idx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
2234 if(notAdmitList->list.array[idx] == NULLP)
2236 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2240 notAdmitItem = (RICaction_NotAdmitted_ItemIEs_t *)notAdmitList->list.array[idx];
2241 notAdmitItem->id = ProtocolIE_IDE2_id_RICaction_NotAdmitted_Item;
2242 notAdmitItem->criticality = CriticalityE2_reject;
2243 notAdmitItem->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;
2244 notAdmitItem->value.choice.RICaction_NotAdmitted_Item.ricActionID = \
2245 subsRspInfo->rejectedActionList[idx].id;
2246 fillE2Cause(¬AdmitItem->value.choice.RICaction_NotAdmitted_Item.cause, \
2247 subsRspInfo->rejectedActionList[idx].failureCause);
2252 /*******************************************************************
2254 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
2258 * Function : FreeRicSubscriptionRsp
2260 * Functionality:Free the RicSubscriptionRsp
2262 * @param[in] E2AP_PDU_t *e2apRicMsg
2266 ******************************************************************/
2267 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
2269 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
2272 RICaction_Admitted_List_t *admitList = NULLP;
2273 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
2275 if(e2apRicMsg != NULLP)
2277 if(e2apRicMsg->choice.successfulOutcome != NULLP)
2279 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2280 if(ricSubscriptionRsp)
2282 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
2284 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
2286 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
2288 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
2290 case ProtocolIE_IDE2_id_RICactions_Admitted:
2292 admitList = &ricSubscriptionRsp->protocolIEs.list.\
2293 array[idx]->value.choice.RICaction_Admitted_List;
2294 if(admitList->list.array != NULLP)
2296 for(listIdx=0 ; listIdx < admitList->list.count; listIdx++)
2298 DU_FREE(admitList->list.array[listIdx], sizeof(RICaction_Admitted_ItemIEs_t));
2300 DU_FREE(admitList->list.array, admitList->list.size);
2304 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
2306 notAdmitList = &ricSubscriptionRsp->protocolIEs.list.\
2307 array[idx]->value.choice.RICaction_NotAdmitted_List;
2308 if(notAdmitList->list.array != NULLP)
2310 for(listIdx=0 ; listIdx < notAdmitList->list.count; listIdx++)
2312 DU_FREE(notAdmitList->list.array[listIdx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
2314 DU_FREE(notAdmitList->list.array, notAdmitList->list.size);
2321 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], sizeof(RICsubscriptionResponse_IEs_t));
2324 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
2327 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2329 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
2333 /*******************************************************************
2335 * @brief Fill RIC Subscription Response IEs
2339 * Function : fillRicSubscriptionRsp
2341 * functionality: Fill RIC Subscription Response IEs
2343 * @param Pointer to RIC subscription response
2344 * Subscription response information
2345 * @return ROK - success
2348 ******************************************************************/
2349 uint8_t fillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp, PendingSubsRspInfo *subsRspInfo)
2352 uint8_t elementCnt = 0;
2353 RICsubscriptionResponse_IEs_t *subsRspIe = NULLP;
2356 if(subsRspInfo->numOfRejectedActions)
2359 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
2360 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
2361 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
2362 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
2364 DU_LOG("\nERROR --> E2AP : Memory allocation failed at %s : line %d", __func__, __LINE__);
2368 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
2370 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionResponse_IEs_t));
2371 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx] == NULLP)
2373 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d] : ieIdx [%d]", __func__, __LINE__,ieIdx);
2378 /* RIC Request ID */
2380 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2381 subsRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
2382 subsRspIe->criticality = CriticalityE2_reject;
2383 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
2384 subsRspIe->value.choice.RICrequestID.ricRequestorID = subsRspInfo->requestId.requestorId;
2385 subsRspIe->value.choice.RICrequestID.ricInstanceID = subsRspInfo->requestId.instanceId;
2387 /* RAN Function ID */
2389 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2390 subsRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
2391 subsRspIe->criticality = CriticalityE2_reject;
2392 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
2393 subsRspIe->value.choice.RANfunctionID = subsRspInfo->ranFuncId;
2395 /* RIC Action Admitted List */
2397 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2398 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_Admitted;
2399 subsRspIe->criticality = CriticalityE2_reject;
2400 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
2401 if(BuildRicActionAdmitList(&subsRspIe->value.choice.RICaction_Admitted_List, subsRspInfo) != ROK)
2403 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Admitted List in RIC Subscription Response");
2407 /* RIC Action Not Admitted List */
2408 if(subsRspInfo->numOfRejectedActions)
2411 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2412 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_NotAdmitted;
2413 subsRspIe->criticality = CriticalityE2_reject;
2414 subsRspIe->criticality = CriticalityE2_reject;
2415 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
2416 if(BuildRicActionNotAdmitList(&subsRspIe->value.choice.RICaction_NotAdmitted_List, subsRspInfo) != ROK)
2418 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Not Admitted List in RIC Subscription Response");
2426 /*******************************************************************
2428 * @brief Builds and Send the RicSubscriptionRsp
2432 * Function : BuildAndSendRicSubscriptionRsp
2434 * Functionality:Fills the RicSubscriptionRsp
2436 * @return ROK - success
2439 ******************************************************************/
2441 uint8_t BuildAndSendRicSubscriptionRsp(PendingSubsRspInfo *subsRspInfo)
2443 uint8_t ret = RFAILED;
2444 E2AP_PDU_t *e2apRicMsg = NULLP;
2445 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
2446 asn_enc_rval_t encRetVal;
2450 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
2452 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
2453 if(e2apRicMsg == NULLP)
2455 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2459 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
2460 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2461 if(e2apRicMsg->choice.successfulOutcome == NULLP)
2463 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
2467 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
2468 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2469 e2apRicMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
2471 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2473 if(fillRicSubscriptionRsp(ricSubscriptionRsp, subsRspInfo) != ROK)
2475 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
2479 /* Prints the Msg formed */
2480 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
2482 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2484 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
2485 if(encRetVal.encoded == ENCODE_FAIL)
2487 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
2488 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2493 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
2494 #ifdef DEBUG_ASN_PRINT
2495 for(int i=0; i< encBufSize; i++)
2497 printf("%x",encBuf[i]);
2502 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2504 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
2513 FreeRicSubscriptionRsp(e2apRicMsg);
2517 /******************************************************************
2519 * @brief Deallocation of memory allocated by aper decoder for e2 setup response
2523 * Function : freeAperDecodingOfE2SetupRsp
2525 * Functionality: Deallocation of memory allocated by aper decoder for e2
2528 * @params[in] E2setupResponse_t *e2SetRspMsg;
2531 * ****************************************************************/
2532 void freeAperDecodingOfE2SetupRsp(E2setupResponse_t *e2SetRspMsg)
2534 uint8_t arrIdx, e2NodeConfigAddAckListIdx;
2535 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
2536 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAddAckList;
2540 if(e2SetRspMsg->protocolIEs.list.array)
2542 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2544 if(e2SetRspMsg->protocolIEs.list.array[arrIdx])
2546 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2548 case ProtocolIE_IDE2_id_TransactionID:
2551 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2553 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.pLMN_Identity.buf);
2554 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID.buf);
2558 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2560 e2NodeConfigAddAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2561 if(e2NodeConfigAddAckList->list.array )
2563 for(e2NodeConfigAddAckListIdx = 0; e2NodeConfigAddAckListIdx< e2NodeConfigAddAckList->list.count; e2NodeConfigAddAckListIdx++)
2565 if(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx])
2567 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx];
2568 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2569 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf);
2570 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2571 e2nodeComponentInterfaceTypeF1);
2572 free(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx]);
2575 free(e2NodeConfigAddAckList->list.array);
2580 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]);
2583 free(e2SetRspMsg->protocolIEs.list.array);
2588 /******************************************************************
2590 * @brief handling of e2 noe config update ack ies
2594 * Function :handleE2NodeConfigUpdateAckIes
2596 * Functionality: handling of e2 noe config update ack ies
2599 * Pointer to the E2 Node cfg
2602 ******************************************************************/
2604 void handleE2NodeConfigUpdateAckIes(PTR e2NodeCfg, uint8_t procedureCode)
2606 CmLList *node=NULLP;
2607 E2NodeComponent *e2NodeComponentInfo=NULLP;
2608 E2nodeComponentID_t *e2nodeComponentID=NULLP;
2609 E2nodeComponentConfigRemovalAck_Item_t *removalAckItem=NULLP;
2610 E2nodeComponentConfigUpdateAck_Item_t *updateAckItem=NULLP;
2611 E2nodeComponentConfigAdditionAck_Item_t *additionAckItem=NULLP;
2613 switch(procedureCode)
2615 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2617 additionAckItem = (E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg;
2618 e2nodeComponentID = &additionAckItem->e2nodeComponentID;
2621 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
2623 updateAckItem = (E2nodeComponentConfigUpdateAck_Item_t*) e2NodeCfg;
2624 e2nodeComponentID = &updateAckItem->e2nodeComponentID;
2627 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
2629 removalAckItem= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
2630 e2nodeComponentID = &removalAckItem->e2nodeComponentID;
2635 switch(e2nodeComponentID->present)
2637 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
2639 e2NodeComponentInfo = fetchE2NodeComponentInfo(F1, e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0], &node);
2640 if(!e2NodeComponentInfo)
2642 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
2651 switch(procedureCode)
2653 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2655 DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, e2NodeComponentInfo->addConfiguration->reqBufSize);
2656 DU_FREE(e2NodeComponentInfo->addConfiguration->componentResponsePart, e2NodeComponentInfo->addConfiguration->rspBufSize);
2657 DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
2660 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
2662 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentRequestPart, e2NodeComponentInfo->updateConfiguration->reqBufSize);
2663 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentResponsePart, e2NodeComponentInfo->updateConfiguration->rspBufSize);
2664 DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
2667 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
2669 cmLListDelFrm(&duCb.e2apDb.e2NodeComponentList, node);
2670 if(e2NodeComponentInfo->addConfiguration)
2672 DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, e2NodeComponentInfo->addConfiguration->reqBufSize);
2673 DU_FREE(e2NodeComponentInfo->addConfiguration->componentResponsePart, e2NodeComponentInfo->addConfiguration->rspBufSize);
2674 DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
2676 if(e2NodeComponentInfo->updateConfiguration)
2678 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentRequestPart, e2NodeComponentInfo->updateConfiguration->reqBufSize);
2679 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentResponsePart, e2NodeComponentInfo->updateConfiguration->rspBufSize);
2680 DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
2682 DU_FREE(node, sizeof(CmLList));
2688 /******************************************************************
2690 * @brief Processes E2 Setup Response sent by RIC
2694 * Function : procE2SetupRsp
2696 * Functionality: Processes E2 Setup Response sent by RIC
2698 * @params[in] E2AP_PDU_t ASN decoded E2AP message
2701 * ****************************************************************/
2703 void procE2SetupRsp(E2AP_PDU_t *e2apMsg)
2705 bool invalidTransId = false;
2706 uint8_t arrIdx =0, transId=0, idx=0;
2707 uint32_t recvBufLen;
2708 E2setupResponse_t *e2SetRspMsg=NULL;
2709 E2nodeComponentConfigAdditionAck_List_t *e2NodeCfgAckList=NULL;
2710 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem=NULL;
2712 DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
2713 duCb.e2Status = TRUE; //Set E2 status as true
2714 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
2716 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2718 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2720 case ProtocolIE_IDE2_id_TransactionID:
2722 transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2723 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
2724 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
2726 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
2730 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
2731 invalidTransId = true;
2736 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2738 /* To store the Ric Id Params */
2739 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value\
2740 .choice.GlobalRIC_ID.pLMN_Identity.size);
2741 memcpy(&duCb.e2apDb.ricId.plmnId, e2SetRspMsg->protocolIEs.list.array[arrIdx]\
2742 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
2743 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID, &duCb.e2apDb.ricId);
2744 /*TODO : duCb.e2apDb.ricId.plmnId memory to be deallocated after the usage */
2748 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2750 e2NodeCfgAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2751 for(idx =0; idx <e2NodeCfgAckList->list.count; idx++)
2753 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeCfgAckList->list.array[idx];
2754 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
2755 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
2762 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
2763 e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
2768 if(invalidTransId == true)
2773 freeAperDecodingOfE2SetupRsp(e2SetRspMsg);
2775 if(invalidTransId == false)
2777 if(duSendE2NodeConfigurationUpdate() != ROK)
2779 DU_LOG("\nERROR --> E2AP : Failed to send E2 node config update");
2784 /*******************************************************************
2786 * @brief Free RIC Subscription Request
2790 * Function : freeAperDecodingOfRicSubsReq
2792 * Functionality : Free RIC Subscription Request
2796 ******************************************************************/
2797 void freeAperDecodingOfRicSubsReq(RICsubscriptionRequest_t *ricSubscriptionReq)
2800 uint8_t elementIdx = 0;
2801 RICsubscriptionDetails_t *subsDetails = NULLP;
2802 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
2804 if(ricSubscriptionReq->protocolIEs.list.array)
2806 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
2808 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
2810 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
2812 subsDetails = &(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails);
2813 free(subsDetails->ricEventTriggerDefinition.buf);
2815 if(subsDetails->ricAction_ToBeSetup_List.list.array)
2817 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
2819 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
2821 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
2822 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
2824 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf);
2825 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition);
2827 free(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]);
2830 free(subsDetails->ricAction_ToBeSetup_List.list.array);
2835 free(ricSubscriptionReq->protocolIEs.list.array[idx]);
2837 free(ricSubscriptionReq->protocolIEs.list.array);
2841 /*******************************************************************
2843 * @brief Free Event Trigger Definition
2847 * Function : freeAperDecodingOfEventTriggerDef
2849 * Functionality: Free Event Trigger Definition
2851 * @params[in] E2SM-KPM Event Trigger Definition
2854 * ****************************************************************/
2855 void freeAperDecodingOfEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
2859 switch(eventTiggerDef->eventDefinition_formats.present)
2861 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
2864 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
2865 free(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1);
2871 /*******************************************************************
2873 * @brief Extract E2SM-KPM Event trigger definition
2877 * Function : extractEventTriggerDef
2879 * Functionality : This function :
2880 * - Decodes E2SM-KPM Event Trigger Definition
2881 * - Validates that even trigger style is supported by E2 node
2882 * - Stores event trigger details in local DB
2884 * @params[in] RAN Function Database structure
2885 * RIC Subscription Info to be added to RAN function
2886 * RIC Event Trigger Definition buffer received from RIC
2887 * @return ROK - success
2890 ******************************************************************/
2891 uint8_t extractEventTriggerDef(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
2892 RICeventTriggerDefinition_t *ricEventTriggerDef, E2FailureCause *failureCause)
2894 uint8_t ret = RFAILED;
2895 uint8_t eventIdx = 0;
2896 asn_dec_rval_t rval ={0};
2897 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef, *eventTiggerDefPtr = NULLP;
2899 /* Decoding E2SM-KPM Even Trigger Definition */
2900 eventTiggerDefPtr = &eventTiggerDef;
2901 memset(eventTiggerDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
2903 rval = aper_decode(0, &asn_DEF_E2SM_KPM_EventTriggerDefinition, (void **)&eventTiggerDefPtr, ricEventTriggerDef->buf,\
2904 ricEventTriggerDef->size, 0, 0);
2905 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2907 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Event Trigger Definition");
2908 failureCause->causeType = E2_PROTOCOL;
2909 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
2913 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, eventTiggerDefPtr);
2915 /* Validating the received event trigger definition format */
2916 for(eventIdx = 0; eventIdx < ranFuncDb->numOfEventTriggerStyleSupported; eventIdx++)
2918 if((eventTiggerDefPtr->eventDefinition_formats.present != \
2919 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING) && \
2920 (eventTiggerDefPtr->eventDefinition_formats.present == ranFuncDb->eventTriggerStyleList[eventIdx].formatType))
2922 ricSubscriptionInfo->eventTriggerDefinition.formatType = ranFuncDb->eventTriggerStyleList[eventIdx].formatType;
2923 ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod = \
2924 eventTiggerDefPtr->eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod;
2933 failureCause->causeType = E2_RIC_REQUEST;
2934 failureCause->cause = E2_EVENT_TRIGGER_NOT_SUPPORTED;
2936 /* Free E2SM_KPM_EventTriggerDefinition_t */
2937 freeAperDecodingOfEventTriggerDef(eventTiggerDefPtr);
2941 /*******************************************************************
2943 * @brief Free RIC Action Definition
2947 * Function : freeAperDecodingOfRicActionDefinition
2949 * Functionality: Free RIC Action Definition
2951 * @params[in] E2SM-KPM Action definition
2954 * ****************************************************************/
2955 void freeAperDecodingOfRicActionDefinition(E2SM_KPM_ActionDefinition_t *actionDef)
2957 uint8_t elementIdx = 0;
2958 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
2959 MeasurementInfoItem_t *measItem = NULLP;
2961 switch(actionDef->actionDefinition_formats.present)
2963 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
2965 if(actionDef->actionDefinition_formats.choice.actionDefinition_Format1)
2967 actionFormat1 = actionDef->actionDefinition_formats.choice.actionDefinition_Format1;
2968 if(actionFormat1->measInfoList.list.array)
2970 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
2972 if(actionFormat1->measInfoList.list.array[elementIdx])
2974 measItem = actionFormat1->measInfoList.list.array[elementIdx];
2975 switch(measItem->measType.present)
2977 case MeasurementType_PR_NOTHING:
2980 case MeasurementType_PR_measName:
2982 free(measItem->measType.choice.measName.buf);
2986 case MeasurementType_PR_measID:
2992 free(actionFormat1->measInfoList.list.array);
2994 free(actionFormat1);
2998 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
2999 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
3000 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
3001 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
3007 /*******************************************************************
3009 * @brief Extract Measurement Info list from action definition
3013 * Function : extractMeasInfoList
3015 * Functionality : This function :
3016 * - Traverses Measurement-to-be-subscribed list
3017 * - Validates that each measurement in Measurement-to-be-subscribed
3018 * list is supported in RAN-Function->Measurement-supported list.
3019 * - If all measurements in an action is supported by RAN function,
3020 * it is added to measurement-subscribed list in local DB
3022 * @params[in] Measurement Info supported list by RAN function
3023 * Measurement Info to be subscribed as requested by RIC
3024 * Measurement Info finally subscribed
3025 * Memory failure indicator
3026 * @return ROK - success
3029 ******************************************************************/
3030 uint8_t extractMeasInfoList(CmLListCp *measInfoSupportedList, MeasurementInfoList_t *measInfoToBeSubscribedList, \
3031 CmLListCp *measInfoSubscribedList, bool *memFailure)
3033 uint8_t elementIdx = 0;
3034 MeasurementInfoForAction *measInfoSupportedDb = NULLP;
3035 MeasurementInfo *measInfoSubscribedDb = NULLP;
3036 CmLList *supportedMeasNode = NULLP, *measToAddNode = NULLP;
3037 MeasurementInfoItem_t *measItem = NULLP;
3039 /* Validate Measurement list is supported by E2 node.
3041 * Traverse and compare the Measurement-Supported List in E2
3042 * node with Measurement-to-be-subscribed list received from RIC.
3043 * If a match is found, add it to measurement-subscription list.
3045 for(elementIdx = 0; elementIdx < measInfoToBeSubscribedList->list.count; elementIdx++)
3047 measInfoSubscribedDb = NULLP;
3048 measToAddNode = NULLP;
3049 measItem = measInfoToBeSubscribedList->list.array[elementIdx];
3051 CM_LLIST_FIRST_NODE(measInfoSupportedList, supportedMeasNode);
3052 while(supportedMeasNode)
3054 measInfoSupportedDb = (MeasurementInfoForAction*)supportedMeasNode->node;
3055 switch(measItem->measType.present)
3057 case MeasurementType_PR_measName:
3059 if(!strcmp(measInfoSupportedDb->measurementTypeName, (char *)measItem->measType.choice.measName.buf))
3061 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
3066 case MeasurementType_PR_measID:
3068 if(measInfoSupportedDb->measurementTypeId == measItem->measType.choice.measID)
3070 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
3077 DU_LOG("\nERROR -> DUAPP: Invalid Measurement-type identifier in \
3078 E2SM-KPM Action Definition Format");
3081 } /* End of switch, for measurement type identifier */
3083 /* If measurement type is supported, add to measurement-subscription list */
3084 if(measInfoSubscribedDb)
3086 measInfoSubscribedDb->measurementTypeId = measInfoSupportedDb->measurementTypeId;
3087 memcpy(measInfoSubscribedDb->measurementTypeName, measInfoSupportedDb->measurementTypeName, \
3088 strlen(measInfoSupportedDb->measurementTypeName));
3090 DU_ALLOC(measToAddNode, sizeof(CmLList));
3093 measToAddNode->node = (PTR) measInfoSubscribedDb;
3094 cmLListAdd2Tail(measInfoSubscribedList, measToAddNode);
3096 /* Break out of while loop if measurement info is found in measurement-supported list */
3101 DU_FREE(measInfoSubscribedDb, sizeof(MeasurementInfo));
3102 measInfoSubscribedDb = NULLP;
3108 supportedMeasNode = supportedMeasNode->next;
3110 } /* End of while for traversing measurement-supported list in a report style */
3112 /* If a measurement-to-be-subscribed is not found in measurement-supported list in this report style
3114 * Delete all entries from measurement-subscription list and
3115 * Break out of for loop to search in next report style */
3116 if(!measInfoSubscribedDb)
3118 deleteMeasurementInfoList(measInfoSubscribedList);
3122 } /* End of for loop , traversing measurement-to-be-subscribed list */
3124 /* If all measurement-to-be-subscribed was found in measurement-supported list and
3125 * was added to measurement-subscription list successfully, return from here */
3126 if(measInfoToBeSubscribedList->list.count == measInfoSubscribedList->count)
3132 /*******************************************************************
3134 * @brief Extract E2SM-KPM Action definition
3138 * Function : extractRicActionDef
3140 * Functionality : This function :
3141 * - Decodes E2SM-KPM Action Definition
3142 * - Validates that action is supported by E2 node
3143 * - Stores action details in local DB
3145 * @params[in] RAN Function Database structure
3146 * RIC subscription's Action definition to be added to
3148 * RIC Action Definition buffer received from RIC
3149 * @return ROK - success
3152 ******************************************************************/
3153 uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefDb, RICactionDefinition_t *ricActionDef,\
3154 E2FailureCause *failureCause)
3156 bool memFailure = false;
3157 uint8_t styleIdx = 0;
3158 asn_dec_rval_t rval ={0};
3160 E2SM_KPM_ActionDefinition_t actionDef, *actionDefPtr = NULLP;
3161 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
3162 CmLListCp *measInfoSupportedList = NULLP;
3163 CmLListCp *measInfoSubscribedList = NULLP;
3165 /* Decoding E2SM-KPM Action Definition */
3166 actionDefPtr = &actionDef;
3167 memset(actionDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
3169 rval = aper_decode(0, &asn_DEF_E2SM_KPM_ActionDefinition, (void **)&actionDefPtr, ricActionDef->buf,\
3170 ricActionDef->size, 0, 0);
3171 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
3173 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Action Definition");
3174 failureCause->causeType = E2_PROTOCOL;
3175 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
3179 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDefPtr);
3182 /* Validate if Report style to subscribe is supported by E2 Node */
3183 for(styleIdx= 0; styleIdx < ranFuncDb->numOfReportStyleSupported; styleIdx++)
3185 /* Validate Report style type and report style format type is supported by E2 Node */
3186 if((ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType == actionDefPtr->ric_Style_Type) &&
3187 (ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType == actionDefPtr->actionDefinition_formats.present))
3189 /* Fetch Report stype type and format type */
3190 actionDefDb->styleType = actionDefPtr->ric_Style_Type;
3191 actionDefDb->formatType = actionDefPtr->actionDefinition_formats.present;
3193 switch(actionDefPtr->actionDefinition_formats.present)
3195 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
3197 actionFormat1 = actionDefPtr->actionDefinition_formats.choice.actionDefinition_Format1;
3199 /* Fetch granularity period */
3200 actionDefDb->choice.format1.granularityPeriod = actionFormat1->granulPeriod;
3202 /* Validate and add the Measurement to subscription list */
3203 measInfoSupportedList = &ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
3204 measInfoSubscribedList = &actionDefDb->choice.format1.measurementInfoList;
3205 if(extractMeasInfoList(measInfoSupportedList, &actionFormat1->measInfoList, \
3206 measInfoSubscribedList, &memFailure) == ROK)
3210 /* Free E2SM_KPM_ActionDefinition_t */
3211 freeAperDecodingOfRicActionDefinition(actionDefPtr);
3216 break; /* End of E2SM-KPM Action definition format 1 case */
3221 DU_LOG("\nERROR -> DUAPP: Only E2SM-KPM Action Definition Format 1 is supported");
3224 } /* End of switch for E2SM-KPM Action definition formats */
3229 failureCause->causeType = E2_MISCELLANEOUS;
3230 failureCause->cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3233 } /* End of for loop, traversing Report-styles-supported list in E2 node */
3235 /* Memset action Db and Free E2SM_KPM_ActionDefinition_t */
3236 memset(actionDefDb, 0, sizeof(ActionDefinition));
3237 freeAperDecodingOfRicActionDefinition(actionDefPtr);
3239 if(failureCause->causeType == E2_NOTHING)
3241 failureCause->causeType = E2_RIC_REQUEST;
3242 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3247 /*******************************************************************
3249 * @brief Extract RIC Action to be setup
3253 * Function : extractRicActionToBeSetup
3255 * Functionality : This function :
3256 * - Validates that each action-to-be-setup is supported by E2 node
3257 * - Stores event trigger details in local DB
3259 * @params[in] RAN Function Database structure
3260 * RIC Subscription Info to be added to RAN function
3261 * RIC Action To Be Setup List received from RIC
3262 * @return ROK - success
3265 ******************************************************************/
3266 uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
3267 RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause, PendingSubsRspInfo *subsRsp)
3269 uint8_t actionIdx = 0;
3270 uint8_t ricActionId = 0;
3271 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
3273 if(actionList->list.array)
3275 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
3277 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)actionList->list.array[actionIdx];
3278 switch(actionItem->id)
3280 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
3282 /* If Action type is REPORT and
3283 * If RIC action definition's extraction and validation passes,
3285 * This action is added to action sequence list of subscription info */
3286 ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
3288 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType == RICactionType_report)
3290 ricSubscriptionInfo->actionSequence[ricActionId].actionId = ricActionId;
3291 ricSubscriptionInfo->actionSequence[ricActionId].type = REPORT;
3293 if(extractRicActionDef(ranFuncDb, &ricSubscriptionInfo->actionSequence[ricActionId].definition, \
3294 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, failureCause) == ROK)
3296 ricSubscriptionInfo->actionSequence[ricActionId].action = CONFIG_ADD;
3297 ricSubscriptionInfo->numOfActions++;
3302 /* In case of any failure, action is rejected
3303 * Added to rejected-action-list in subscription response */
3304 deleteActionSequence(&ricSubscriptionInfo->actionSequence[ricActionId]);
3306 subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId;
3307 if(failureCause->causeType == E2_NOTHING)
3309 failureCause->causeType = E2_RIC_REQUEST;
3310 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3312 memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \
3313 failureCause, sizeof(E2FailureCause));
3314 subsRsp->numOfRejectedActions++;
3318 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
3324 /* If there is even 1 action that can be added, return ROK */
3325 if(ricSubscriptionInfo->numOfActions)
3328 if(failureCause->causeType == E2_NOTHING)
3330 failureCause->causeType = E2_RIC_REQUEST;
3331 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3336 /******************************************************************
3338 * @brief Processes RIC Subscription Req sent by RIC
3342 * Function : procRicSubscriptionRequest
3344 * Functionality: Processes RIC Subscription Request from RIC
3346 * @params[in] E2AP_PDU_t ASN decoded E2AP message
3347 * @return ROK - success
3350 * ****************************************************************/
3351 uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg)
3353 uint8_t idx = 0, actionIdx = 0;
3355 uint16_t ranFuncId = 0;
3356 RicRequestId ricReqId;
3357 CmLList *ricSubscriptionNode = NULLP;
3358 RanFunction *ranFuncDb = NULLP;
3359 RICsubscriptionRequest_t *ricSubsReq = NULLP;
3360 RICsubscriptionDetails_t *subsDetails = NULLP;
3361 RicSubscription *ricSubscriptionInfo = NULLP;
3362 E2FailureCause failureCause;
3364 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
3366 memset(&failureCause, 0, sizeof(E2FailureCause));
3367 memset(&ricReqId, 0, sizeof(RicRequestId));
3369 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
3370 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
3372 if(ricSubsReq->protocolIEs.list.array[idx])
3374 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
3376 case ProtocolIE_IDE2_id_RICrequestID:
3378 ricReqId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID;
3379 ricReqId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID;
3384 case ProtocolIE_IDE2_id_RANfunctionID:
3386 ranFuncId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID;
3388 /* Validating RAN Function id */
3389 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
3393 failureCause.causeType = E2_RIC_REQUEST;
3394 failureCause.cause = E2_RAN_FUNCTION_ID_INVALID;
3399 if(ranFuncDb->numPendingSubsRsp >= MAX_PENDING_SUBSCRIPTION_RSP)
3401 failureCause.causeType = E2_RIC_REQUEST;
3402 failureCause.cause = E2_FUNCTION_RESOURCE_LIMIT;
3407 DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription));
3408 if(!ricSubscriptionInfo)
3410 DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
3411 failureCause.causeType = E2_MISCELLANEOUS;
3412 failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3416 ricSubscriptionInfo->requestId.requestorId = ricReqId.requestorId;
3417 ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId;
3418 ricSubscriptionInfo->ranFuncId = ranFuncId;
3420 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
3422 ricSubscriptionInfo->actionSequence[actionIdx].actionId = -1;
3425 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3426 memcpy(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].requestId,
3427 &ricReqId, sizeof(RicRequestId));
3428 ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].ranFuncId = ranFuncId;
3432 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
3434 subsDetails = &ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails;
3436 /* Decode, Validate and record Event Trigger Definition */
3437 if(extractEventTriggerDef(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricEventTriggerDefinition, \
3438 &failureCause) != ROK)
3444 /* Decode, Validate and record RIC actions */
3445 if(extractRicActionToBeSetup(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricAction_ToBeSetup_List, \
3446 &failureCause, &ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp]) != ROK)
3455 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
3456 ricSubsReq->protocolIEs.list.array[idx]->id);
3465 freeAperDecodingOfRicSubsReq(ricSubsReq);
3469 cmInitTimers(&(ricSubscriptionInfo->ricSubsReportTimer), 1);
3470 ricSubscriptionInfo->action = CONFIG_ADD;
3472 /* Add RAN subcription detail to RAN function */
3473 DU_ALLOC(ricSubscriptionNode, sizeof(CmLList));
3474 if(ricSubscriptionNode)
3476 ricSubscriptionNode->node = (PTR) ricSubscriptionInfo;
3477 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubscriptionNode);
3480 ranFuncDb->numPendingSubsRsp++;
3482 #ifdef KPI_CALCULATION
3483 /* Send statistics request to other DU entities */
3484 BuildAndSendStatsReq(ricSubscriptionInfo);
3489 DU_FREE(ricSubscriptionInfo, sizeof(RicSubscription));
3493 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3496 /* Send RIC Subcription Failure */
3497 BuildAndSendRicSubscriptionFailure(ricReqId, ranFuncId, failureCause);
3502 /******************************************************************
3504 * @brief Free RIC Subscription Failure
3508 * Function : FreeRicSubscriptionFailure
3510 * Functionality: Free RIC Subscription Failure
3512 * @params[in] E2AP PDU
3515 * ****************************************************************/
3516 void FreeRicSubscriptionFailure(E2AP_PDU_t *e2apMsg)
3518 uint8_t elemIdx = 0;
3519 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3523 if(e2apMsg->choice.unsuccessfulOutcome)
3525 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3526 if(ricSubscriptionFailure->protocolIEs.list.array)
3528 for(elemIdx = 0; elemIdx < ricSubscriptionFailure->protocolIEs.list.count; elemIdx++)
3530 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3532 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3534 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3536 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3540 /******************************************************************
3542 * @brief Fill and Send RIC Subscription Failure to RIC
3546 * Function : BuildAndSendRicSubscriptionFailure
3548 * Functionality: Fill and Send RIC Subscription Failure to RIC
3550 * @params[in] RIC Request ID
3553 * @return ROK - success
3556 * ****************************************************************/
3557 uint8_t BuildAndSendRicSubscriptionFailure(RicRequestId ricReqId, uint16_t ranFuncId, E2FailureCause failureCause)
3559 uint8_t ret = RFAILED;
3560 uint8_t elementCnt = 0, elemIdx = 0;
3561 E2AP_PDU_t *e2apMsg = NULLP;
3562 asn_enc_rval_t encRetVal; /* Encoder return value */
3563 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3564 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3568 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Failure\n");
3570 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3571 if(e2apMsg == NULLP)
3573 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3577 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3578 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3579 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3581 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3584 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
3585 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3586 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure;
3588 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3591 ricSubscriptionFailure->protocolIEs.list.count = elementCnt;
3592 ricSubscriptionFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionFailure_IEs_t *);
3593 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3594 if(!ricSubscriptionFailure->protocolIEs.list.array)
3596 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3600 for(elemIdx = 0; elemIdx < elementCnt; elemIdx++)
3602 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3603 if(!ricSubscriptionFailure->protocolIEs.list.array[elemIdx])
3605 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d] for IE at index [%d]", \
3606 __func__, __LINE__, elemIdx);
3610 if(elemIdx < elementCnt)
3615 /* RIC Request ID */
3616 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3617 ricSubsFailIe->id = ProtocolIE_IDE2_id_RICrequestID;
3618 ricSubsFailIe->criticality = CriticalityE2_reject;
3619 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
3620 ricSubsFailIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3621 ricSubsFailIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3623 /* RAN Function ID */
3624 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3625 ricSubsFailIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3626 ricSubsFailIe->criticality = CriticalityE2_reject;
3627 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
3628 ricSubsFailIe->value.choice.RANfunctionID = ranFuncId;
3631 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3632 ricSubsFailIe->id = ProtocolIE_IDE2_id_CauseE2;
3633 ricSubsFailIe->criticality = CriticalityE2_reject;
3634 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_CauseE2;
3635 fillE2Cause(&ricSubsFailIe->value.choice.CauseE2, failureCause);
3637 /* Prints the Msg formed */
3638 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3639 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3641 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3642 if(encRetVal.encoded == ENCODE_FAIL)
3644 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Failure Message (at %s)\n",\
3645 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3650 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Failure Message \n");
3651 #ifdef DEBUG_ASN_PRINT
3652 for(int i=0; i< encBufSize; i++)
3654 printf("%x",encBuf[i]);
3659 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
3661 DU_LOG("\nINFO --> E2AP : Sending RIC Subscription Failure");
3667 FreeRicSubscriptionFailure(e2apMsg);
3671 /*******************************************************************
3673 * @brief Free the RicIndication Message
3677 * Function : FreeRicIndication
3679 * Functionality: Free the RicIndication Message
3684 ******************************************************************/
3685 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
3688 RICindication_t *ricIndicationMsg= NULLP;
3690 if(e2apMsg != NULLP)
3692 if(e2apMsg->choice.initiatingMessage != NULLP)
3694 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
3695 if(ricIndicationMsg!= NULLP)
3697 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
3699 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
3701 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
3703 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
3705 case ProtocolIE_IDE2_id_RICrequestID:
3706 case ProtocolIE_IDE2_id_RANfunctionID:
3707 case ProtocolIE_IDE2_id_RICactionID:
3708 case ProtocolIE_IDE2_id_RICindicationType:
3711 case ProtocolIE_IDE2_id_RICindicationHeader:
3713 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
3714 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
3717 case ProtocolIE_IDE2_id_RICindicationMessage:
3719 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
3720 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
3726 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
3729 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
3732 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3734 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3738 /*******************************************************************
3740 * @brief Free measurement record
3744 * Function : freeMeasRecord
3746 * Functionality: Free all measurement recorded for a measurement
3747 * within an action in a RIC subscription
3749 * @param Measurement data to be freed
3752 ******************************************************************/
3753 void freeMeasData(MeasurementData_t *measData)
3755 uint8_t measIdx = 0, measRecIdx = 0;
3756 MeasurementRecord_t *measRecord = NULLP;
3758 if(measData->list.array)
3760 for(measIdx = 0; measIdx < measData->list.count; measIdx++)
3762 if(measData->list.array[measIdx])
3764 measRecord = &measData->list.array[measIdx]->measRecord;
3765 if(measRecord->list.array)
3767 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3769 DU_FREE(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3771 DU_FREE(measRecord->list.array, measRecord->list.size);
3773 DU_FREE(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
3776 DU_FREE(measData->list.array, measData->list.size);
3780 /*******************************************************************
3782 * @brief Fill measurement info list
3786 * Function : freeMeasInfoList
3788 * Functionality: Fills all measurement info within an action
3789 * in a RIC subscription
3791 * @param Measurement Info list to be freed
3794 ******************************************************************/
3795 void freeMeasInfoList(MeasurementInfoList_t *measInfoList)
3797 uint8_t measInfoIdx = 0;
3799 if(measInfoList->list.array)
3801 for(measInfoIdx = 0; measInfoIdx < measInfoList->list.count; measInfoIdx++)
3803 if(measInfoList->list.array[measInfoIdx])
3805 DU_FREE(measInfoList->list.array[measInfoIdx]->measType.choice.measName.buf, \
3806 measInfoList->list.array[measInfoIdx]->measType.choice.measName.size);
3808 DU_FREE(measInfoList->list.array[measInfoIdx], measInfoList->list.size);
3811 DU_FREE(measInfoList->list.array, measInfoList->list.size);
3815 /*******************************************************************
3817 * @brief Free E2SM-KPM Indication Message
3821 * Function : FreeE2smKpmIndicationMessage
3823 * Functionality: Free E2SM-KPM Indication Message
3825 * @param E2SM-KPM Indication message to be freed
3828 ******************************************************************/
3829 void FreeE2smKpmIndicationMessage(E2SM_KPM_IndicationMessage_t *e2smKpmIndMsg)
3831 E2SM_KPM_IndicationMessage_Format1_t *format1Msg = NULLP;
3833 switch(e2smKpmIndMsg->indicationMessage_formats.present)
3835 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
3837 if(e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1)
3839 format1Msg = e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1;
3841 /* Measurement Data */
3842 freeMeasData(&format1Msg->measData);
3844 /* Measurement Info List */
3845 if(format1Msg->measInfoList)
3847 freeMeasInfoList(format1Msg->measInfoList);
3848 DU_FREE(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
3851 /* Granularity Period */
3852 DU_FREE(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
3854 DU_FREE(format1Msg, sizeof(E2SM_KPM_IndicationMessage_Format1_t));
3859 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
3860 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
3866 /*******************************************************************
3868 * @brief Fill measurement record
3872 * Function : fillMeasRecord
3874 * Functionality: Fills all measurement value for a measurement
3875 * within an action in a RIC subscription
3877 * @param Measurement record to be filled
3878 * Measurement database with measurement records
3879 * @return ROK - success
3882 ******************************************************************/
3883 uint8_t fillMeasRecord(MeasurementRecord_t *measRecord, MeasurementInfo *measInfoDb)
3885 uint8_t measRecIdx = 0;
3886 CmLList *measValNode = NULLP;
3889 measRecord->list.count = measInfoDb->measuredValue.count;
3890 measRecord->list.size = measRecord->list.count * sizeof(MeasurementRecordItem_t *);
3892 DU_ALLOC(measRecord->list.array, measRecord->list.size);
3893 if(!measRecord->list.array)
3895 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3899 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3901 DU_ALLOC(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3902 if(!measRecord->list.array[measRecIdx])
3904 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3910 CM_LLIST_FIRST_NODE(&measInfoDb->measuredValue, measValNode);
3913 measVal = *(double *)measValNode->node;
3914 if(measVal == (int)measVal)
3916 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_integer;
3917 measRecord->list.array[measRecIdx]->choice.integer = (int)measVal;
3921 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_real;
3922 measRecord->list.array[measRecIdx]->choice.real = measVal;
3925 measValNode= measValNode->next;
3926 /* Once the measurement record is added to the message, delete it from DB */
3929 deleteMeasuredValueList(&measInfoDb->measuredValue);
3933 /*******************************************************************
3935 * @brief Fills measuerement data
3939 * Function : fillMeasData
3941 * Functionality: Fill all measurement recorded for all measurements
3942 * in an action in a RIC subscription
3944 * @param Measurement data to be filled
3945 * Measurement info list from an action DB
3946 * @return ROK - success
3949 ******************************************************************/
3950 uint8_t fillMeasData(MeasurementData_t *measData, CmLListCp *measInfoListDb)
3952 uint8_t measIdx = 0;
3953 CmLList *measInfoNode = NULLP;
3954 MeasurementInfo *measInfoDb = NULLP;
3955 MeasurementRecord_t *measRecord = NULLP;
3957 measData->list.count = measInfoListDb->count;
3958 measData->list.size = measData->list.count * sizeof(MeasurementDataItem_t *);
3960 DU_ALLOC(measData->list.array, measData->list.size);
3961 if(!measData->list.array)
3963 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3968 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
3971 measInfoDb = (MeasurementInfo *)measInfoNode->node;
3974 DU_ALLOC(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
3975 if(!measData->list.array[measIdx])
3977 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3981 measRecord = &measData->list.array[measIdx]->measRecord;
3982 if(fillMeasRecord(measRecord, measInfoDb) != ROK)
3984 DU_LOG("\nERROR --> E2AP : Failed to fill measurement record");
3989 measInfoNode = measInfoNode->next;
3995 /*******************************************************************
3997 * @brief Fill all measurement info
4001 * Function : fillMeasInfoList
4003 * Functionality: Fills all measurement info belonging to an action
4004 * in a RIC subscription
4006 * @param Measurement Info list to be filled
4007 * Measurement Info list from E2AP DB
4008 * @return ROK - success
4011 ******************************************************************/
4012 uint8_t fillMeasInfoList(MeasurementInfoList_t *measInfoList, CmLListCp *measInfoListDb)
4014 uint8_t measInfoIdx = 0;
4015 CmLList *measInfoNode = NULLP;
4016 MeasurementInfo *measInfoDb = NULLP;
4017 MeasurementInfoItem_t *measInfoItem = NULLP;
4019 measInfoList->list.count = measInfoListDb->count;
4020 measInfoList->list.size = measInfoList->list.count * sizeof(MeasurementInfoItem_t *);
4022 DU_ALLOC(measInfoList->list.array, measInfoList->list.size);
4023 if(!measInfoList->list.array)
4025 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4030 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4033 DU_ALLOC(measInfoList->list.array[measInfoIdx], sizeof(MeasurementInfoItem_t));
4034 if(!measInfoList->list.array[measInfoIdx])
4036 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4040 measInfoItem = measInfoList->list.array[measInfoIdx];
4041 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4044 /* Measurement Type */
4045 measInfoItem->measType.present = MeasurementType_PR_measName;
4046 measInfoItem->measType.choice.measName.size = strlen(measInfoDb->measurementTypeName);
4048 DU_ALLOC(measInfoItem->measType.choice.measName.buf, measInfoItem->measType.choice.measName.size);
4049 if(!measInfoItem->measType.choice.measName.buf)
4051 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4055 memcpy(measInfoItem->measType.choice.measName.buf, measInfoDb->measurementTypeName,\
4056 measInfoItem->measType.choice.measName.size);
4060 measInfoNode = measInfoNode->next;
4067 /*******************************************************************
4069 * @brief Fill E2SM-KPM Indication Message Format 1
4073 * Function : fillE2smKpmIndMsgFormat1
4075 * Functionality: Fill E2SM-KPM Indication Message Format 1
4077 * @param Format 1 Message to be filled
4078 * Action Definition format 1 from E2AP DB
4079 * @return ROK - success
4082 ******************************************************************/
4083 uint8_t fillE2smKpmIndMsgFormat1(E2SM_KPM_IndicationMessage_Format1_t *format1Msg, ActionDefFormat1 *format1)
4085 /* Measurement Data */
4086 if(fillMeasData(&format1Msg->measData, &format1->measurementInfoList) != ROK)
4088 DU_LOG("\nERROR --> E2AP : Failed to fill measurement data");
4092 /* Measurement Information */
4093 DU_ALLOC(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
4094 if(!format1Msg->measInfoList)
4096 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4100 if(fillMeasInfoList(format1Msg->measInfoList, &format1->measurementInfoList) != ROK)
4102 DU_LOG("\nERROR --> E2AP : Failed to fill measurement information list");
4106 /* Granularity Period */
4107 DU_ALLOC(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
4108 if(!format1Msg->granulPeriod)
4110 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4113 *(format1Msg->granulPeriod) = format1->granularityPeriod;
4118 /*******************************************************************
4120 * @brief Fill RIC Indication Message buffer
4124 * Function : fillRicIndMsgBuf
4126 * Functionality: Fill E2SM-KPM Indication Message
4127 * Encode this message and copy to RIC Indication Message buffer
4129 * @param RIC Indication Message buffer to be filled
4130 * Source action info from E2AP DB
4131 * @return ROK - success
4134 ******************************************************************/
4135 uint8_t fillRicIndMsgBuf(RICindicationMessage_t *ricIndMsgBuf, ActionInfo *actionInfo)
4137 uint8_t ret = RFAILED;
4138 bool failedInFormat = false;
4139 E2SM_KPM_IndicationMessage_t e2smKpmIndMsg;
4140 asn_enc_rval_t encRetVal; /* Encoder return value */
4142 memset(&e2smKpmIndMsg, 0, sizeof(E2SM_KPM_IndicationMessage_t));
4146 /* E2SM-KPM Indication message format type */
4147 e2smKpmIndMsg.indicationMessage_formats.present = actionInfo->definition.formatType;
4148 switch(e2smKpmIndMsg.indicationMessage_formats.present)
4150 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
4152 /* E2SM-KPM Indication message format 1 */
4153 DU_ALLOC(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4154 sizeof(E2SM_KPM_IndicationMessage_Format1_t));
4155 if(!e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1)
4157 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4158 failedInFormat = true;
4162 if(fillE2smKpmIndMsgFormat1(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4163 &actionInfo->definition.choice.format1) != ROK)
4165 DU_LOG("\nERROR --> E2AP : Failed to fill E2SM-KPM Indication message format 1");
4166 failedInFormat = true;
4172 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
4173 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
4176 DU_LOG("\nERROR --> E2AP : fillRicIndMsgBuf: Only Format 1 supported");
4177 failedInFormat = true;
4185 /* Encode E2SM-KPM Indication Message */
4186 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationMessage, &e2smKpmIndMsg);
4187 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4189 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationMessage, 0, &e2smKpmIndMsg, PrepFinalEncBuf, encBuf);
4190 if(encRetVal.encoded == ENCODE_FAIL)
4192 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Message (at %s)\n",\
4193 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4198 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Message \n");
4199 #ifdef DEBUG_ASN_PRINT
4200 for(int i=0; i< encBufSize; i++)
4202 printf("%x",encBuf[i]);
4207 /* Copy encoded string to RIC Indication Message buffer */
4208 ricIndMsgBuf->size = encBufSize;
4209 DU_ALLOC(ricIndMsgBuf->buf, ricIndMsgBuf->size);
4210 if(!ricIndMsgBuf->buf)
4212 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4215 memset(ricIndMsgBuf->buf, 0, ricIndMsgBuf->size);
4216 memcpy(ricIndMsgBuf->buf, encBuf, encBufSize);
4222 /* Free E2SM-KPM Indication Message */
4223 FreeE2smKpmIndicationMessage(&e2smKpmIndMsg);
4228 /*******************************************************************
4230 * @brief Free E2SM-KPM Indication Header
4234 * Function : FreeE2smKpmIndicationHeader
4236 * Functionality: Free E2SM-KPM Indication Header
4238 * @param E2SM-KPM Indication Header to be free
4241 ******************************************************************/
4242 void FreeE2smKpmIndicationHeader(E2SM_KPM_IndicationHeader_t *e2smKpmIndHdr)
4244 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4248 switch(e2smKpmIndHdr->indicationHeader_formats.present)
4250 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4252 if(e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1)
4254 format1 = e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1;
4256 DU_FREE(format1->colletStartTime.buf, format1->colletStartTime.size);
4257 DU_FREE(format1, sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4261 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4268 /*******************************************************************
4270 * @brief Fill RIC Indication Header buffer
4274 * Function : fillRicIndHeader
4276 * Functionality: Fill E2SM-KPM Indication Header
4277 * Encode this message and copy to RIC Indication Header buffer
4279 * @param RIC Indication Header buffer to be filled
4280 * Source RIC subscription info from E2AP DB
4281 * @return ROK - success
4284 ******************************************************************/
4285 uint8_t fillRicIndHeader(RICindicationHeader_t *ricIndHdr, RicSubscription *ricSubsInfo)
4287 uint8_t ret = RFAILED;
4288 uint8_t secBufIdx = 0, milliSecBufIdx = 0;
4290 bool formatFailure = false;
4291 RanFunction *ranFunc = NULLP;
4292 ReportStartTime *startTime = NULLP;
4293 E2SM_KPM_IndicationHeader_t e2smKpmIndHdr;
4294 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4295 asn_enc_rval_t encRetVal; /* Encoder return value */
4299 ranFunc = fetchRanFuncFromRanFuncId(ricSubsInfo->ranFuncId);
4300 if(ranFunc == NULLP)
4302 DU_LOG("\nERROR --> E2AP : RAN Function ID [%d] not found", ricSubsInfo->ranFuncId);
4306 memset(&e2smKpmIndHdr, 0, sizeof(E2SM_KPM_IndicationHeader_t));
4308 e2smKpmIndHdr.indicationHeader_formats.present = ranFunc->ricIndicationHeaderFormat;
4309 switch(e2smKpmIndHdr.indicationHeader_formats.present)
4311 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4313 DU_ALLOC(e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1, \
4314 sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4315 if(!e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1)
4317 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4318 formatFailure = true;
4321 format1 = e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1;
4323 /* Fetch reporting period start time from DB */
4324 switch(ricSubsInfo->eventTriggerDefinition.formatType)
4328 startTime = &ricSubsInfo->eventTriggerDefinition.choice.format1.startTime;
4332 format1->colletStartTime.size = 8 * sizeof(uint8_t);
4333 DU_ALLOC(format1->colletStartTime.buf, format1->colletStartTime.size);
4334 if(!format1->colletStartTime.buf)
4336 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4337 formatFailure = true;
4341 /* As per O-RAN.WG3.E2SM-KPM-R003-v03.00, section 8.3.12 and
4342 * RFC 5905, section 6 :
4343 * Time stamp has a 64-bit format where first 32-bit is seconds
4344 * and next 32-bit is fraction in picosecond-level.
4345 * This fraction has been rounded in microseconds.
4348 * Storing 32-bit seconds at MSB 0-3 and
4349 * 32-bit milliseconds at next 4 bytes i.e. bytes 4-7
4353 for(byteIdx = 3; byteIdx >= 0; byteIdx--)
4355 format1->colletStartTime.buf[secBufIdx++] = startTime->timeInSec >> (8*byteIdx);
4356 format1->colletStartTime.buf[milliSecBufIdx++] = startTime->timeInMilliSec >> (8*byteIdx);
4361 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4364 DU_LOG("\nERROR --> E2AP : Only E2SM-KPM Indication Header Format 1 supported");
4365 formatFailure = true;
4373 /* Encode E2SM-KPM Indication Header */
4374 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationHeader, &e2smKpmIndHdr);
4375 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4377 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationHeader, 0, &e2smKpmIndHdr, PrepFinalEncBuf, encBuf);
4378 if(encRetVal.encoded == ENCODE_FAIL)
4380 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Header (at %s)\n",\
4381 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4386 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Header \n");
4387 #ifdef DEBUG_ASN_PRINT
4388 for(int i=0; i< encBufSize; i++)
4390 printf("%x",encBuf[i]);
4395 /* Copy encoded string to RIC Indication Header buffer */
4396 ricIndHdr->size = encBufSize;
4397 DU_ALLOC(ricIndHdr->buf, ricIndHdr->size);
4400 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4403 memset(ricIndHdr->buf, 0, ricIndHdr->size);
4404 memcpy(ricIndHdr->buf, encBuf, encBufSize);
4409 /* Free E2SM-KPM Indication Header */
4410 FreeE2smKpmIndicationHeader(&e2smKpmIndHdr);
4415 /*******************************************************************
4417 * brief Fill the RIC Indication Message
4421 * Function : fillRicIndication
4423 * Functionality: Fills the RIC Indication Message
4425 * @param RIC Indication Message to be filled
4426 * RIC Subscription DB
4428 * @return ROK - success
4431 ******************************************************************/
4432 uint8_t fillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4434 uint8_t elementCnt = 0, idx = 0;
4439 ricIndicationMsg->protocolIEs.list.count = elementCnt;
4440 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_IEs_t *);
4442 /* Initialize the Ric Indication members */
4443 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, ricIndicationMsg->protocolIEs.list.size);
4444 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
4446 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4450 for(idx=0; idx<elementCnt; idx++)
4452 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx], sizeof(RICindication_IEs_t));
4453 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
4455 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4460 /* RIC Request ID */
4462 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
4463 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4464 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICrequestID;
4465 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = \
4466 ricSubscriptionInfo->requestId.requestorId;
4467 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = \
4468 ricSubscriptionInfo->requestId.instanceId;
4470 /* RAN Function ID */
4472 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
4473 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4474 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RANfunctionID;
4475 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ricSubscriptionInfo->ranFuncId;
4479 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
4480 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4481 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICactionID;
4482 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = actionInfo->actionId;
4484 /* RIC Indication Type */
4486 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
4487 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4488 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationType;
4489 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = actionInfo->type;
4491 /* RIC Indication Header */
4493 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
4494 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4495 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationHeader;
4496 if(fillRicIndHeader(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader, \
4497 ricSubscriptionInfo) != ROK)
4499 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication header");
4503 /* RIC Indication Message */
4505 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
4506 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4507 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationMessage;
4508 if(fillRicIndMsgBuf(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage, \
4511 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication Message");
4518 /*******************************************************************
4520 * @brief Builds and Send the RicIndication Message
4524 * Function : BuildAndSendRicIndication
4526 * Functionality:Fills the RicIndication Message
4528 * @return ROK - success
4531 ******************************************************************/
4533 uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4535 uint8_t ret = RFAILED;
4536 E2AP_PDU_t *e2apMsg = NULLP;
4537 RICindication_t *ricIndicationMsg = NULLP;
4538 asn_enc_rval_t encRetVal; /* Encoder return value */
4542 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
4544 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4545 if(e2apMsg == NULLP)
4547 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4551 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4552 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4553 if(e2apMsg->choice.initiatingMessage == NULLP)
4555 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4558 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
4559 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4560 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
4562 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
4564 if(fillRicIndication(ricIndicationMsg, ricSubscriptionInfo, actionInfo) != ROK)
4566 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication message");
4570 /* Prints the Msg formed */
4571 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4572 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4574 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4576 if(encRetVal.encoded == ENCODE_FAIL)
4578 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
4579 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4584 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
4585 #ifdef DEBUG_ASN_PRINT
4586 for(int i=0; i< encBufSize; i++)
4588 printf("%x",encBuf[i]);
4593 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
4595 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
4601 FreeRicIndication(e2apMsg);
4605 /*******************************************************************
4607 * @brief free e2 node component configuration req and rsp
4611 * Function : freeE2NodeComponentConfiguration
4614 * - free e2 node component configuration req and rsp
4616 * @params[in] E2nodeComponentConfiguration_t *e2nodeComponentConfiguration
4617 * @return ROK - success
4620 * ****************************************************************/
4622 void freeE2NodeComponentConfiguration(E2nodeComponentConfiguration_t *e2nodeComponentConfiguration)
4624 /* Free E2 Node Component Request Part */
4625 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentRequestPart.buf, e2nodeComponentConfiguration->e2nodeComponentRequestPart.size);
4627 /* Free E2 Node Component Response Part */
4628 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentResponsePart.buf, e2nodeComponentConfiguration->e2nodeComponentResponsePart.size);
4632 /*******************************************************************
4634 * @brief free e2 node component component identifier
4638 * Function : freeE2NodeComponentIdentifier
4641 * - free e2 node component component identifier
4643 * @params[in] E2nodeComponentID_t *componentID
4644 * @return ROK - success
4647 * ****************************************************************/
4649 void freeE2NodeComponentIdentifier(E2nodeComponentID_t *componentID)
4651 if(componentID->choice.e2nodeComponentInterfaceTypeF1)
4653 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
4654 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
4659 /*******************************************************************
4661 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
4665 * Function : FreeE2NodeConfigUpdate
4668 * - freeing the memory allocated for E2nodeConfigurationUpdate
4670 * @params[in] E2AP_PDU_t *e2apMsg
4671 * @return ROK - success
4674 * ****************************************************************/
4676 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
4678 uint8_t arrIdx =0, e2NodeUpdateListIdx=0, e2NodeRemovalListIdx=0, e2NodeAddListIdx=0;
4679 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate =NULL;
4680 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList =NULL;
4681 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItem =NULL;
4682 E2nodeComponentConfigRemoval_List_t *e2NodeRemovalList =NULL;
4683 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItem =NULL;
4684 E2nodeComponentConfigAddition_List_t *e2NodeAddList =NULL;
4685 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem =NULL;
4687 if(e2apMsg != NULLP)
4689 if(e2apMsg->choice.initiatingMessage != NULLP)
4691 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4692 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
4694 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
4696 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx])
4699 switch(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id)
4701 case ProtocolIE_IDE2_id_TransactionID:
4704 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
4706 e2NodeAddList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
4707 if(e2NodeAddList->list.array)
4709 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
4711 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
4713 freeE2NodeComponentConfiguration(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration);
4714 freeE2NodeComponentIdentifier(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID);
4715 DU_FREE(e2NodeAddItem, sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
4717 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
4721 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
4723 e2NodeUpdateList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List;
4724 if(e2NodeUpdateList->list.array)
4726 for(e2NodeUpdateListIdx = 0; e2NodeUpdateListIdx< e2NodeUpdateList->list.count; e2NodeUpdateListIdx++)
4728 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[e2NodeUpdateListIdx];
4730 freeE2NodeComponentConfiguration(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentConfiguration);
4731 freeE2NodeComponentIdentifier(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentID);
4732 DU_FREE(e2NodeUpdateItem, sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
4734 DU_FREE(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
4738 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
4740 e2NodeRemovalList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List;
4741 if(e2NodeRemovalList->list.array)
4743 for(e2NodeRemovalListIdx = 0; e2NodeRemovalListIdx< e2NodeRemovalList->list.count; e2NodeRemovalListIdx++)
4745 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemovalList->list.array[e2NodeRemovalListIdx];
4747 freeE2NodeComponentIdentifier(&e2NodeRemovalItem->value.choice.E2nodeComponentConfigRemoval_Item.e2nodeComponentID);
4748 DU_FREE(e2NodeRemovalItem, sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
4750 DU_FREE(e2NodeRemovalList->list.array, e2NodeRemovalList->list.size);
4758 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4761 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4763 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4765 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4769 /*******************************************************************
4771 * @brief Buld and send the E2 node config update msg
4775 * Function : BuildAndSendE2NodeConfigUpdate
4778 * - Buld and send the E2 node config update msg
4781 * @return ROK - success
4784 * ****************************************************************/
4786 uint8_t BuildAndSendE2NodeConfigUpdate(E2NodeConfigList *e2NodeList)
4788 uint8_t ret = RFAILED;
4789 uint8_t arrIdx = 0,elementCnt = 0, transId=0;
4790 E2AP_PDU_t *e2apMsg = NULLP;
4791 asn_enc_rval_t encRetVal; /* Encoder return value */
4792 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
4794 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
4797 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4798 if(e2apMsg == NULLP)
4800 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4804 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4805 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4806 if(e2apMsg->choice.initiatingMessage == NULLP)
4808 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4811 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4812 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
4813 e2apMsg->choice.initiatingMessage->value.present = \
4814 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
4815 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4818 if(e2NodeList->addE2NodeCount)
4820 if(e2NodeList->updateE2NodeCount)
4822 if(e2NodeList->removeE2NodeCount)
4825 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
4826 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
4827 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4828 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
4830 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4834 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
4836 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4837 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
4840 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4845 if(arrIdx<elementCnt)
4849 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4850 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4851 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
4852 transId = assignTransactionId();
4853 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4855 if(e2NodeList->addE2NodeCount)
4858 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
4859 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4860 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigAddition_List;
4861 if(BuildE2NodeConfigAddList(&(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List),\
4862 ProcedureCodeE2_id_E2nodeConfigurationUpdate, e2NodeList->addE2NodeCount, e2NodeList->addE2Node)!=ROK)
4864 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
4869 if(e2NodeList->updateE2NodeCount)
4872 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate;
4873 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4874 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigUpdate_List;
4875 if(BuildE2NodeConfigUpdateList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List,\
4876 e2NodeList->updateE2NodeCount, e2NodeList->updateE2Node) != ROK)
4879 DU_LOG("\nERROR --> E2AP : Failed to update the E2 node configuration");
4884 if(e2NodeList->removeE2NodeCount)
4887 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval;
4888 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4889 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigRemoval_List;
4890 if(BuildE2NodeConfigRemoveList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List,\
4891 e2NodeList->removeE2NodeCount, e2NodeList->removeE2Node) != ROK)
4894 DU_LOG("\nERROR --> E2AP : Failed to remove the E2 node configuration");
4899 /* Prints the Msg formed */
4900 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4902 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4904 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
4905 if(encRetVal.encoded == ENCODE_FAIL)
4907 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
4908 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4913 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
4914 #ifdef DEBUG_ASN_PRINT
4915 for(int i=0; i< encBufSize; i++)
4917 printf("%x",encBuf[i]);
4921 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
4923 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
4927 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
4928 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
4929 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.e2NodeConfigUpdate.configList, e2NodeList, sizeof(E2NodeConfigList));
4934 FreeE2NodeConfigUpdate(e2apMsg);
4938 /*******************************************************************
4940 * @brief Deallocate the memory allocated for E2ResetRequest msg
4944 * Function : FreeE2ResetRequest
4947 * - freeing the memory allocated for E2ResetRequest
4949 * @params[in] E2AP_PDU_t *e2apMsg
4950 * @return ROK - success
4953 * ****************************************************************/
4954 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
4957 ResetRequestE2_t *resetReq = NULLP;
4959 if(e2apMsg != NULLP)
4961 if(e2apMsg->choice.initiatingMessage != NULLP)
4963 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4964 if(resetReq->protocolIEs.list.array)
4966 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
4968 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4970 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4972 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4974 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4978 /*******************************************************************
4980 * @brief Build and send the E2 reset request msg
4984 * Function : BuildAndSendE2ResetRequest
4987 * - Buld and send the E2 reset request msg to RIC
4991 * @return ROK - success
4994 * ****************************************************************/
4995 uint8_t BuildAndSendE2ResetRequest(E2FailureCause resetCause)
4997 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
4998 uint8_t ret = RFAILED;
4999 E2AP_PDU_t *e2apMsg = NULLP;
5000 ResetRequestE2_t *resetReq = NULLP;
5001 asn_enc_rval_t encRetVal; /* Encoder return value */
5003 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
5007 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5008 if(e2apMsg == NULLP)
5010 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
5014 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5015 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5016 if(e2apMsg->choice.initiatingMessage == NULLP)
5018 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
5022 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
5023 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5024 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
5025 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5028 resetReq->protocolIEs.list.count = elementCnt;
5029 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
5031 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5032 if(!resetReq->protocolIEs.list.array)
5034 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5035 Reset Request IE array");
5039 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5041 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5042 if(!resetReq->protocolIEs.list.array[ieIdx])
5044 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5045 Reset Request IE array element");
5050 /* In case of failure */
5051 if(ieIdx < elementCnt)
5055 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5056 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
5057 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
5058 transId = assignTransactionId();
5059 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
5062 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
5063 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
5064 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
5065 fillE2Cause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, resetCause);
5067 /* Prints the Msg formed */
5068 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5070 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5072 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
5074 if(encRetVal.encoded == ENCODE_FAIL)
5076 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
5077 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5082 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
5083 #ifdef DEBUG_ASN_PRINT
5084 for(int i=0; i< encBufSize; i++)
5086 printf("%x",encBuf[i]);
5090 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5092 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5096 /* In case the message is sent successfully, store the transaction info to
5097 * be used when response is received */
5098 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5099 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5105 /* Free all memory */
5106 FreeE2ResetRequest(e2apMsg);
5110 /*******************************************************************
5112 * @brief Deallocate the memory allocated for Reset Response msg
5116 * Function : freeAperDecodingOfE2ResetRsp
5119 * - freeing the memory allocated for Reset response
5121 * @params[in] ResetResponseE2_t *resetResponse
5124 * ****************************************************************/
5125 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
5131 if(resetResponse->protocolIEs.list.array)
5133 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5135 if(resetResponse->protocolIEs.list.array[ieIdx])
5137 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5139 case ProtocolIE_IDE2_id_TransactionID:
5142 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5145 free(resetResponse->protocolIEs.list.array[ieIdx]);
5148 free(resetResponse->protocolIEs.list.array);
5153 /******************************************************************
5155 * @brief Processes E2 Reset Response sent by RIC
5159 * Function : procResetResponse
5161 * Functionality: Processes E2 Reset Response sent by RIC
5163 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5166 * ****************************************************************/
5167 void procResetResponse(E2AP_PDU_t *e2apMsg)
5169 bool invalidTransId=false;
5170 uint8_t ieIdx =0, transId =0;
5171 uint16_t ranFuncIdx=0;
5172 ResetResponseE2_t *resetResponse =NULLP;
5174 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
5175 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
5177 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5179 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5181 case ProtocolIE_IDE2_id_TransactionID:
5183 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5184 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \
5185 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
5187 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5191 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5192 invalidTransId = true;
5196 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5198 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
5200 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
5202 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
5203 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
5210 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
5211 resetResponse->protocolIEs.list.array[ieIdx]->id);
5216 if(invalidTransId == true)
5222 freeAperDecodingOfE2ResetRsp(resetResponse);
5225 /******************************************************************
5227 * @brief Deallocation of memory allocated by aper decoder for e2 setup Failure
5231 * Function : freeAperDecodingOfE2SetupFailure
5233 * Functionality: Deallocation of memory allocated by aper decoder for e2
5236 * @params[in] E2setupFailure_t *e2SetupFailure;
5239 * ****************************************************************/
5240 void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure)
5246 if(e2SetupFailure->protocolIEs.list.array)
5248 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5250 if(e2SetupFailure->protocolIEs.list.array[arrIdx])
5252 free(e2SetupFailure->protocolIEs.list.array[arrIdx]);
5255 free(e2SetupFailure->protocolIEs.list.array);
5259 /******************************************************************
5261 * @brief Processes E2 Setup Failure sent by RIC
5265 * Function : procE2SetupFailure
5267 * Functionality: Processes E2 Setup failure sent by RIC
5269 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5270 * @return ROK - success
5273 * ****************************************************************/
5274 void procE2SetupFailure(E2AP_PDU_t *e2apMsg)
5276 uint8_t arrIdx =0, transId =0, timerValue=0;
5277 E2setupFailure_t *e2SetupFailure;
5279 DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
5280 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
5282 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5284 switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id)
5286 case ProtocolIE_IDE2_id_TransactionID:
5288 transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5289 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
5290 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5292 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5296 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5301 case ProtocolIE_IDE2_id_TimeToWaitE2:
5303 timerValue = convertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
5304 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE)
5306 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue);
5310 DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
5318 freeAperDecodingOfE2SetupFailure(e2SetupFailure);
5320 /******************************************************************
5322 * @brief Deallocation of memory allocated by aper decoder for RIC service Query
5326 * Function : freeAperDecodingOfRicServiceQuery
5328 * Functionality: Deallocation of memory allocated by aper decoder for RIC
5331 * @params[in] RICserviceQuery_t *ricServiceQuery;
5334 * ****************************************************************/
5336 void freeAperDecodingOfRicServiceQuery(RICserviceQuery_t *ricServiceQuery)
5338 uint8_t arrIdx,ranFuncIdx;
5339 RANfunctionsID_List_t *ranFuncAddedList;
5343 if(ricServiceQuery->protocolIEs.list.array)
5345 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5347 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
5349 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5351 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5353 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5354 if(ranFuncAddedList->list.array)
5356 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5358 free(ranFuncAddedList->list.array[ranFuncIdx]);
5360 free(ranFuncAddedList->list.array);;
5367 free(ricServiceQuery->protocolIEs.list.array[arrIdx]);
5370 free(ricServiceQuery->protocolIEs.list.array);
5374 /*******************************************************************
5376 * @brief Build RanFunction Delete List
5380 * Function : BuildRanFunctionDeleteList
5382 * Functionality: Build RanFunction Delete List
5385 * RANfunctionsID List
5386 * Count of the RAN function
5387 * Received RAN function list
5389 * @return ROK - success
5392 ******************************************************************/
5394 uint8_t BuildRanFunctionDeleteList(RANfunctionsID_List_t *deleteList, uint8_t count, RanFuncInfo *recvdRanFunc)
5396 uint8_t ranFuncIdx=0;
5397 RANfunctionID_ItemIEs_t *delRanFuncItem;
5401 deleteList->list.count = count;
5402 deleteList->list.size = deleteList->list.count * sizeof(RANfunctionID_ItemIEs_t*);
5403 DU_ALLOC(deleteList->list.array, deleteList->list.size);
5404 if(deleteList->list.array == NULLP)
5406 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5409 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
5411 DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t));
5412 if(deleteList->list.array[ranFuncIdx] == NULLP)
5414 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5417 delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx];
5418 delRanFuncItem->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
5419 delRanFuncItem->criticality = CriticalityE2_ignore;
5420 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionID = recvdRanFunc[ranFuncIdx].id;
5421 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionRevision = recvdRanFunc[ranFuncIdx].revisionCounter;
5427 /*******************************************************************
5429 * @brief De Allocate Ric Service Update message
5433 * Function : FreeRicServiceUpdate
5435 * Functionality: De-Allocating Ric Service Update message
5437 * @params[in] E2AP_PDU_t *e2apMsg
5441 * ****************************************************************/
5443 void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg)
5446 uint8_t ranFuncAddListIdx=0, ranFuncDelIdx=0;
5447 RICserviceUpdate_t *ricServiceUpdate;
5448 RANfunctions_List_t *ranFunctionsList;
5449 RANfunction_ItemIEs_t *ranFuncItemIe;
5450 RANfunction_Item_t *ranFunItem;
5451 RANfunctionsID_List_t *deleteList;
5453 /* De-allocating Memory */
5454 if(e2apMsg != NULLP)
5456 if(e2apMsg->choice.initiatingMessage != NULLP)
5458 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5459 if(ricServiceUpdate->protocolIEs.list.array != NULLP)
5461 for(arrIdx = 0; arrIdx < ricServiceUpdate->protocolIEs.list.count; arrIdx++)
5463 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] != NULLP)
5465 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
5467 case ProtocolIE_IDE2_id_TransactionID:
5470 case ProtocolIE_IDE2_id_RANfunctionsAdded:
5471 case ProtocolIE_IDE2_id_RANfunctionsModified:
5473 ranFunctionsList = &(ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
5474 if(ranFunctionsList->list.array)
5476 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
5478 if(ranFunctionsList->list.array[ranFuncAddListIdx])
5480 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
5481 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
5482 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
5483 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
5484 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
5487 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
5491 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
5493 deleteList= &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5494 if(deleteList->list.array)
5496 for(ranFuncDelIdx = 0; ranFuncDelIdx< deleteList->list.count; ranFuncDelIdx++)
5498 DU_FREE(deleteList->list.array[ranFuncDelIdx], sizeof(RANfunctionID_ItemIEs_t));
5500 DU_FREE(deleteList->list.array, deleteList->list.size);
5506 DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
5507 (ricServiceUpdate->protocolIEs.list.array[arrIdx]->id));
5510 DU_FREE(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5513 DU_FREE(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5515 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5517 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5521 /*******************************************************************
5523 * @brief Builds and Send the RicServiceUpdateuest
5527 * Function : BuildAndSendRicServiceUpdate
5529 * Functionality:Fills the RicServiceUpdateuest
5531 * @return ROK - success
5534 ******************************************************************/
5536 uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate)
5538 uint8_t arrIdx = 0, elementCnt=0;
5539 uint8_t transId = 0, ret = RFAILED;
5540 bool memAllocFailed =false;
5541 E2AP_PDU_t *e2apMsg = NULLP;
5542 RICserviceUpdate_t *ricServiceUpdate = NULLP;
5543 asn_enc_rval_t encRetVal; /* Encoder return value */
5545 DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n");
5548 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5549 if(e2apMsg == NULLP)
5551 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5554 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5555 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5556 if(e2apMsg->choice.initiatingMessage == NULLP)
5558 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5561 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5562 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
5563 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceUpdate;
5564 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5566 /* For TransId IE, set elementCnt to 1.
5567 If there is any item in the RAN function add list, RAN function modification list, or RAN function delete list, increment the elementCnt.*/
5570 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5572 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5574 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5577 ricServiceUpdate->protocolIEs.list.count = elementCnt;
5578 ricServiceUpdate->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdate_IEs_t*);
5580 /* Initialize the E2Setup members */
5581 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5582 if(ricServiceUpdate->protocolIEs.list.array == NULLP)
5584 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
5588 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
5590 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5591 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP)
5593 memAllocFailed = true;
5594 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
5598 if(memAllocFailed == true)
5604 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5605 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5606 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
5607 if(serviceUpdate.dir == E2_NODE_INITIATED)
5608 transId = assignTransactionId();
5610 transId = serviceUpdate.transId;
5611 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5613 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5616 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
5617 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5618 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5619 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,\
5620 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded, serviceUpdate.recvRanFuncList.ranFunToBeAdded) !=ROK)
5626 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5629 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsModified;
5630 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5631 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5632 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,
5633 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeModified, serviceUpdate.recvRanFuncList.ranFunToBeModified) !=ROK)
5639 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5642 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsDeleted;
5643 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5644 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctionsID_List;
5645 if(BuildRanFunctionDeleteList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List,\
5646 serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted, serviceUpdate.recvRanFuncList.ranFunToBeDeleted) != ROK)
5651 /* Prints the Msg formed */
5652 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5654 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5656 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5657 if(encRetVal.encoded == ENCODE_FAIL)
5659 DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
5660 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5665 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
5666 #ifdef DEBUG_ASN_PRINT
5667 for(int i=0; i< encBufSize; i++)
5669 printf("%x",encBuf[i]);
5673 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5675 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5684 if(serviceUpdate.dir == E2_NODE_INITIATED)
5686 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5687 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5691 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId = transId;
5692 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5694 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.dir = serviceUpdate.dir;
5695 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.transId =transId;
5696 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.recvRanFuncList, &serviceUpdate.recvRanFuncList, sizeof(E2TmpRanFunList));
5698 FreeRicServiceUpdate(e2apMsg);
5701 /******************************************************************
5703 * @brief Processes RIC service Query sent by RIC
5707 * Function : procRicServiceQuery
5709 * Functionality: Processes RIC service Query sent by RIC
5711 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5712 * @return ROK - success
5715 * ****************************************************************/
5717 void procRicServiceQuery(E2AP_PDU_t *e2apMsg)
5720 uint16_t arrIdx =0, ranFuncIdx=0,tmpIdx=0;
5721 uint16_t id,revisionCcounter;
5722 bool tmpArray[MAX_RAN_FUNCTION] = {false};
5723 RICserviceQuery_t *ricServiceQuery=NULL;
5724 RicServiceUpdate ricUpdate;
5725 RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
5726 RANfunctionsID_List_t *ranFuncAddedList;
5728 DU_LOG("\nINFO --> E2AP : RIC Service Query received");
5729 memset(&ricUpdate, 0, sizeof(RicServiceUpdate));
5730 ricUpdate.dir = RIC_INITIATED;
5731 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
5733 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5735 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5737 /* TODO completing in next patch/gerrit */
5738 case ProtocolIE_IDE2_id_TransactionID:
5740 ricUpdate.transId = ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5744 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5746 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5747 if(ranFuncAddedList->list.array)
5749 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5751 if(ranFuncAddedList->list.array[ranFuncIdx])
5753 /* Using the RAN function Id, identify the RAN function to be modified or deleted. */
5755 ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
5756 id = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID;
5757 revisionCcounter = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision;
5759 if((id != duCb.e2apDb.ranFunction[id-1].id))
5761 action = CONFIG_DEL;
5763 else if((id == duCb.e2apDb.ranFunction[id-1].id)&&(revisionCcounter!=duCb.e2apDb.ranFunction[id-1].revisionCounter))
5765 action = CONFIG_MOD;
5768 if(action == CONFIG_DEL)
5770 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].id = id;
5771 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].revisionCounter = revisionCcounter;
5772 ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted++;
5774 else if(action == CONFIG_MOD)
5776 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].id = id;
5777 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].revisionCounter = revisionCcounter;
5778 ricUpdate.recvRanFuncList.numOfRanFunToBeModified++;
5781 /* If any ID is set to true, it means that the ID has been used in either modification or deletion list.
5782 * Else we will add the IDs into the added list */
5783 tmpArray[id-1] = true;
5792 /* Traversing the whole RAN function list in ducb to check if any new Ran function ids have been added. */
5793 for(arrIdx =0; arrIdx<MAX_RAN_FUNCTION; arrIdx++)
5795 tmpIdx= ricUpdate.recvRanFuncList.numOfRanFunToBeAdded;
5796 if((duCb.e2apDb.ranFunction[arrIdx].id >0)&&(!tmpArray[arrIdx]))
5798 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[arrIdx].id;
5799 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[arrIdx].revisionCounter;
5800 ricUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
5804 if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK)
5806 DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message");
5809 freeAperDecodingOfRicServiceQuery(ricServiceQuery);
5812 /******************************************************************
5814 * @brief Deallocation of memory allocated by aper decoder for
5815 * RIC service update ack
5819 * Function : freeAperDecodingOfRicServiceUpdateAck
5821 * Functionality: Deallocation of memory allocated by aper decoder
5822 * for RIC service update ack
5824 * @params[in] RICserviceUpdateAck_t *ricServiceAck;
5827 * ****************************************************************/
5829 void freeAperDecodingOfRicServiceUpdateAck(RICserviceUpdateAcknowledge_t *ricServiceAck)
5831 uint8_t arrIdx=0,ranFuncIdx=0;
5832 RANfunctionsID_List_t *ranFuncAddedList=NULL;
5836 if(ricServiceAck->protocolIEs.list.array)
5838 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5840 if(ricServiceAck->protocolIEs.list.array[arrIdx])
5842 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5844 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5846 ranFuncAddedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5847 if(ranFuncAddedList->list.array)
5849 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5851 free(ranFuncAddedList->list.array[ranFuncIdx]);
5853 free(ranFuncAddedList->list.array);
5860 free(ricServiceAck->protocolIEs.list.array[arrIdx]);
5863 free(ricServiceAck->protocolIEs.list.array);
5868 /******************************************************************
5870 * @brief Processes RIC service update ack sent by RIC
5874 * Function : procRicServiceUpdateAck
5876 * Functionality: Processes RIC service update ack sent by RIC
5878 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5879 * @return ROK - success
5882 * ****************************************************************/
5884 void procRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
5886 uint8_t arrIdx =0, transId =0;
5887 uint16_t id =0, tmpIdx=0, ranFuncIdx=0;
5888 RicServiceUpdate serviceUpdate;
5889 RANfunctionsIDcause_List_t *rejectedList=NULL;
5890 RICserviceUpdateAcknowledge_t *ricServiceAck=NULL;
5891 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
5893 DU_LOG("\nINFO --> E2AP : RIC service update ack received");
5894 memset(&serviceUpdate, 0, sizeof(RicServiceUpdate));
5895 ricServiceAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
5897 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5899 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5901 case ProtocolIE_IDE2_id_TransactionID:
5903 transId = ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5904 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
5905 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5907 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5909 else if((duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId == transId) &&\
5910 (duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5912 memset(&duCb.e2apDb.e2TransInfo.ricInitTransaction[transId], 0, sizeof(E2TransInfo));
5916 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5922 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5925 case ProtocolIE_IDE2_id_RANfunctionsRejected:
5927 rejectedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
5928 if(rejectedList->list.array)
5930 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
5932 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)rejectedList->list.array[ranFuncIdx];
5933 id = ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID;
5934 tmpIdx= serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded;
5935 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[id-1].id;
5936 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[id-1].revisionCounter;
5937 serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
5946 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5948 serviceUpdate.dir = E2_NODE_INITIATED;
5949 BuildAndSendRicServiceUpdate(serviceUpdate);
5951 freeAperDecodingOfRicServiceUpdateAck(ricServiceAck);
5954 /******************************************************************
5956 * @brief Deallocation of memory allocated by aper decoder for
5957 * RIC service update failure
5961 * Function : freeAperDecodingOfRicServiceUpdateFailure
5963 * Functionality: Deallocation of memory allocated by aper decoder
5964 * for RIC service update failure
5966 * @params[in] RICserviceUpdateFailure_t *ricServiceFailure;
5969 * ****************************************************************/
5971 void freeAperDecodingOfRicServiceUpdateFailure(RICserviceUpdateFailure_t *ricServiceFailure)
5975 if(ricServiceFailure)
5977 if(ricServiceFailure->protocolIEs.list.array)
5979 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
5981 if(ricServiceFailure->protocolIEs.list.array[arrIdx])
5983 free(ricServiceFailure->protocolIEs.list.array[arrIdx]);
5986 free(ricServiceFailure->protocolIEs.list.array);
5991 /******************************************************************
5993 * @brief Processes RIC service update failure sent by RIC
5997 * Function : procRicServiceUpdateFailure
5999 * Functionality: Processes RIC service update failure sent by RIC
6001 * @params[in] E2AP_PDU_t ASN decoded E2AP message
6002 * @return ROK - success
6005 * ****************************************************************/
6007 void procRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
6009 uint8_t arrIdx =0, timerValue=0;
6010 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
6012 DU_LOG("\nINFO --> E2AP : RIC service update failure received");
6013 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
6015 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6017 switch(ricServiceFailure->protocolIEs.list.array[arrIdx]->id)
6019 case ProtocolIE_IDE2_id_TransactionID:
6023 case ProtocolIE_IDE2_id_TimeToWaitE2:
6025 timerValue = convertE2WaitTimerEnumToValue(ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
6026 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR)) == FALSE)
6028 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR, timerValue);
6032 DU_LOG("\nERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running");
6037 case ProtocolIE_IDE2_id_CauseE2:
6044 freeAperDecodingOfRicServiceUpdateFailure(ricServiceFailure);
6047 /******************************************************************
6049 * @brief DU Send E2 Node Configuration Update
6053 * Function : duSendE2NodeConfigurationUpdate
6055 * Functionality: DU Send E2 Node Configuration Update
6057 * @return ROK - success
6060 * ****************************************************************/
6062 uint8_t duSendE2NodeConfigurationUpdate()
6064 E2NodeConfigList e2NodeList;
6065 CmLList *node =NULL;
6066 E2NodeComponent *e2NodeComponentInfo=NULL;
6068 memset(&e2NodeList, 0, sizeof(E2NodeConfigList));
6069 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
6072 e2NodeComponentInfo = (E2NodeComponent*)node->node;
6074 if(e2NodeComponentInfo->addConfiguration)
6076 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6077 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6078 e2NodeList.addE2NodeCount++;
6081 if(e2NodeComponentInfo->updateConfiguration)
6083 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6084 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6085 e2NodeList.updateE2NodeCount++;
6088 if(e2NodeComponentInfo->deleteConfiguration == true)
6090 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6091 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].componentId = e2NodeComponentInfo->componentId;
6092 e2NodeList.removeE2NodeCount++;
6098 if(BuildAndSendE2NodeConfigUpdate(&e2NodeList) !=ROK)
6100 DU_LOG("\nERROR --> E2AP : Failed to build and send e2 node config update message to RIC_stub");
6106 /*******************************************************************
6108 * @brief Free RIC Subscription Modification Required
6112 * Function : FreeRicSubsModRequired
6114 * Functionality: Freqq RIC Subscription Modification required
6116 * @param E2AP Message PDU to be freed
6119 ******************************************************************/
6120 void FreeRicSubsModRequired(E2AP_PDU_t *e2apMsg)
6122 uint8_t ieIdx = 0, arrIdx = 0;
6123 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6124 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6125 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6126 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6130 if(e2apMsg->choice.initiatingMessage)
6132 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6133 if(ricSubsModReqd->protocolIEs.list.array)
6135 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
6137 if(ricSubsModReqd->protocolIEs.list.array[ieIdx])
6139 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6140 switch(ricSubsModReqdIe->id)
6142 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
6144 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6145 if(actionToBeModList->list.array)
6147 for(arrIdx = 0; arrIdx < actionToBeModList->list.count; arrIdx++)
6149 DU_FREE(actionToBeModList->list.array[arrIdx], \
6150 sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6152 DU_FREE(actionToBeModList->list.array, actionToBeModList->list.size);
6157 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
6159 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6160 if(actionToBeRmvList->list.array)
6162 for(arrIdx = 0; arrIdx < actionToBeRmvList->list.count; arrIdx++)
6164 DU_FREE(actionToBeRmvList->list.array[arrIdx], \
6165 sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6167 DU_FREE(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6175 DU_FREE(ricSubsModReqd->protocolIEs.list.array[ieIdx], \
6176 sizeof(RICsubscriptionModificationRequired_IEs_t));
6179 DU_FREE(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6181 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6183 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6187 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6188 * However, E2SM-KPM supports only RIC Report service.
6189 * Hence there is no subsequent action in RIC subscription that may require modification.
6190 * So commenting the action-modification IEs for the time being
6193 /*******************************************************************
6195 * @brief Fill Action required to be modified list
6199 * Function : FillActionReqdToBeModList
6201 * Functionality: Fill Action required to be modified list
6203 * @param RIC Actions Required To Be Modified List to be filled
6204 * Number of actions to be modified
6205 * RIC Subscription DB
6206 * @return ROK - success
6209 ******************************************************************/
6210 uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod, \
6211 RicSubscription *ricSubscription)
6213 uint8_t arrIdx = 0, actionIdx = 0;
6214 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL;
6216 actionToBeModList->list.count = numActionsMod;
6217 actionToBeModList->list.size = numActionsMod * sizeof(RICaction_RequiredToBeModified_ItemIEs_t *);
6218 DU_ALLOC(actionToBeModList->list.array, actionToBeModList->list.size);
6219 if(!actionToBeModList->list.array)
6221 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6226 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
6228 if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD)
6230 DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6231 if(!actionToBeModList->list.array[arrIdx])
6233 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6236 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[arrIdx];
6238 actionToBeMod->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeModified_Item;
6239 actionToBeMod->criticality = CriticalityE2_reject;
6240 actionToBeMod->value.present = \
6241 RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item;
6242 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \
6243 ricSubscription->actionSequence[actionIdx].actionId;
6244 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms;
6254 /*******************************************************************
6256 * @brief Fill Action required to be removed list
6260 * Function : FillActionReqdToBeRmvList
6262 * Functionality: Fill Action required to be removed list
6264 * @param RIC Actions Required To Be Removed List to be filled
6265 * Number of actions to be removed
6266 * RIC Subscription DB
6267 * @return ROK - success
6270 ******************************************************************/
6271 uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \
6272 RicSubscription *ricSubscription)
6274 uint8_t arrIdx = 0, actionIdx = 0;
6275 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL;
6277 actionToBeRmvList->list.count = numActionsRmv;
6278 actionToBeRmvList->list.size = numActionsRmv * sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t *);
6279 DU_ALLOC(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6280 if(!actionToBeRmvList->list.array)
6282 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6287 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
6289 if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL)
6291 DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6292 if(!actionToBeRmvList->list.array[arrIdx])
6294 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6297 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[arrIdx];
6299 actionToBeRmv->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeRemoved_Item;
6300 actionToBeRmv->criticality = CriticalityE2_reject;
6301 actionToBeRmv->value.present = \
6302 RICaction_RequiredToBeRemoved_ItemIEs__value_PR_RICaction_RequiredToBeRemoved_Item;
6303 actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = \
6304 ricSubscription->actionSequence[actionIdx].actionId;
6305 fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, \
6306 ricSubscription->actionSequence[actionIdx].failureCause);
6315 /*******************************************************************
6317 * @brief Fill RIC Subscription Modification Required IEs
6321 * Function : FillRicSubsModRequired
6323 * Functionality: Fill RIC Subscription Modification Required IEs
6325 * @param RIC Subscription Modification Required IEs to be filled
6326 * RIC Subscription DB
6327 * @return ROK - success
6330 ******************************************************************/
6331 uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription)
6333 uint8_t ieIdx = 0, elementCnt=0, actionIdx = 0;
6334 uint8_t numActionsMod = 0, numActionsRmv = 0;
6335 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6336 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6338 /* Unused in case of E2SM-KPM */
6340 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6343 /* Count number of Actions to be modified or deleted */
6344 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
6346 if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD)
6348 else if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL)
6352 /* Count number of IEs to be added to messages */
6359 ricSubsModReqd->protocolIEs.list.count = elementCnt;
6360 ricSubsModReqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequired_IEs_t *);
6361 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6362 if(!ricSubsModReqd->protocolIEs.list.array)
6364 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6368 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
6370 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRequired_IEs_t));
6371 if(!ricSubsModReqd->protocolIEs.list.array[ieIdx])
6373 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6378 /* RIC Request ID */
6380 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6381 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICrequestID;
6382 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6383 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RICrequestID;
6384 ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID = ricSubscription->requestId.requestorId;
6385 ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID = ricSubscription->requestId.instanceId;
6387 /* RAN Function ID */
6389 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6390 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RANfunctionID;
6391 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6392 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RANfunctionID;
6393 ricSubsModReqdIe->value.choice.RANfunctionID = ricSubscription->ranFuncId;
6395 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6396 * However, E2SM-KPM supports only RIC Report service.
6397 * Hence there is no subsequent action in RIC subscription that may require modification.
6398 * So commenting the action-modification IEs for the time being
6401 /* RIC Actions Required to be Modified */
6405 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6406 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List;
6407 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6408 ricSubsModReqdIe->value.present = \
6409 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeModified_List;
6410 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6412 if(FillActionReqdToBeModList(actionToBeModList, numActionsMod, ricSubscription) != ROK)
6414 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__);
6420 /* RIC Actions Required to be removed */
6424 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6425 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List;
6426 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6427 ricSubsModReqdIe->value.present = \
6428 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeRemoved_List;
6429 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6431 if(FillActionReqdToBeRmvList(actionToBeRmvList, numActionsRmv, ricSubscription) != ROK)
6433 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__);
6441 /*******************************************************************
6443 * @brief Builds and Send RIC Subscription Modification Required
6448 * Function : BuildAndSendRicSubsModRequired
6450 * Functionality: Builds and Send RIC Subscription Modification
6453 * @param RIC Subscription DB
6454 * @return ROK - success
6457 ******************************************************************/
6458 uint8_t BuildAndSendRicSubsModRequired(RicSubscription *ricSubscription)
6460 uint8_t ret = RFAILED;
6461 E2AP_PDU_t *e2apMsg = NULLP;
6462 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6463 asn_enc_rval_t encRetVal; /* Encoder return value */
6465 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Required \n");
6468 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6469 if(e2apMsg == NULLP)
6471 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6475 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6476 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6477 if(e2apMsg->choice.initiatingMessage == NULLP)
6479 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6482 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6483 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
6484 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired;
6486 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6488 if(FillRicSubsModRequired(ricSubsModReqd, ricSubscription) != ROK)
6490 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__);
6495 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6497 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6499 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6500 if(encRetVal.encoded == ENCODE_FAIL)
6502 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modifiction Required structure (at %s)\n",\
6503 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6508 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Required \n");
6509 #ifdef DEBUG_ASN_PRINT
6510 for(int i=0; i< encBufSize; i++)
6512 printf("%x",encBuf[i]);
6516 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
6518 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Modification Required failed");
6525 /* Free RIC Subscription modification required */
6526 FreeRicSubsModRequired(e2apMsg);
6530 /*******************************************************************
6532 * @brief Free APER decoding of RIC Subscription Modification Confirm
6536 * Function : freeAperDecodingOfRicSubsModConfirm
6538 * Functionality: Free APER decoding of RIC Subscription
6539 * Modification Confirm
6541 * @param E2AP Message PDU
6544 ******************************************************************/
6545 void freeAperDecodingOfRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
6547 uint8_t ieIdx = 0, arrIdx=0;
6548 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6549 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6550 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6551 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6552 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6553 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6555 if(e2apMsg && e2apMsg->choice.successfulOutcome)
6557 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6558 if(ricSubsModCfm->protocolIEs.list.array)
6560 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6562 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
6564 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6565 switch(ricSubsModCfmIe->id)
6567 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6569 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6570 if(modCfmList->list.array)
6572 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6574 if(modCfmList->list.array[arrIdx])
6575 free(modCfmList->list.array[arrIdx]);
6577 free(modCfmList->list.array);
6582 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6584 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6585 if(modRefusedList->list.array)
6587 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6589 if(modRefusedList->list.array[arrIdx])
6590 free(modRefusedList->list.array[arrIdx]);
6592 free(modRefusedList->list.array);
6597 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6599 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6600 if(rmvCfmList->list.array)
6602 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6604 if(rmvCfmList->list.array[arrIdx])
6605 free(rmvCfmList->list.array[arrIdx]);
6607 free(rmvCfmList->list.array);
6612 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6614 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6615 if(rmvFailList->list.array)
6617 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6619 if(rmvFailList->list.array[arrIdx])
6620 free(rmvFailList->list.array[arrIdx]);
6622 free(rmvFailList->list.array);
6631 free(ricSubsModCfmIe);
6634 free(ricSubsModCfm->protocolIEs.list.array);
6639 /*******************************************************************
6641 * @brief Process RIC Subscription Modification Confirm Message
6645 * Function : procRicSubscriptionModificationConfirm
6647 * Functionality: Process RIC Subscription Modification Confirm
6648 * Message received from RIC.
6650 * @param E2AP Message PDU
6653 ******************************************************************/
6654 void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg)
6656 uint8_t actionId = 0, ieIdx = 0, arrIdx = 0;
6657 uint16_t ranFuncId = 0;
6658 bool procFailure = false;
6659 RicRequestId ricReqId;
6660 RanFunction *ranFuncDb = NULLP;
6661 CmLList *ricSubsNode = NULLP;
6662 RicSubscription *ricSubsDb = NULLP;
6663 ActionInfo *actionDb = NULLP;
6665 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6666 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6668 /* Not used in case of E2SM-KPM */
6670 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6671 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
6673 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6674 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
6677 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6678 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
6680 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6681 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
6683 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Confirm", __func__);
6688 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
6692 if(!e2apMsg->choice.successfulOutcome)
6694 DU_LOG("\nERROR --> E2AP : %s: Successful Outcome in E2AP message is NULL", __func__);
6698 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6699 if(!ricSubsModCfm->protocolIEs.list.array)
6701 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
6705 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6707 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
6709 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
6713 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6714 switch(ricSubsModCfmIe->id)
6716 case ProtocolIE_IDE2_id_RICrequestID:
6718 memset(&ricReqId, 0, sizeof(RicRequestId));
6719 ricReqId.requestorId = ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID;
6720 ricReqId.instanceId = ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID;
6724 case ProtocolIE_IDE2_id_RANfunctionID:
6726 ranFuncId = ricSubsModCfmIe->value.choice.RANfunctionID;
6727 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
6730 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
6735 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
6738 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
6739 __func__, ricReqId.requestorId, ricReqId.instanceId);
6747 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6748 * However, E2SM-KPM supports only RIC Report service.
6749 * Hence there is no subsequent action in RIC subscription that may require modification.
6750 * So commenting the action-modification IEs for the time being
6753 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6755 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6756 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6758 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
6759 actionId = modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID;
6761 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
6764 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6768 actionDb->action = CONFIG_UNKNOWN;
6769 /* Further handling can be added here in future once the
6770 * use case of this procedure is identified */
6777 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6779 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6780 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6782 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
6783 actionId = modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID;
6784 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
6787 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6791 /* Spec doesnt mention if in case of failure, DU should retry for modify action
6792 * Hence, chaging the action from CONFIG_MOD to CONFIG_UNKNOWN
6794 actionDb->action = CONFIG_UNKNOWN;
6802 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6804 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6805 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6807 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
6808 actionId = rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID;
6809 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
6812 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6816 deleteActionSequence(actionDb);
6818 ricSubsDb->numOfActions--;
6819 /* Further handling can include :
6820 * Deletion of this action from all DU layers
6828 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6830 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6831 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6833 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
6834 actionId = rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID;
6835 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
6838 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6842 actionDb->action = CONFIG_UNKNOWN;
6851 } /* End of switch for Protocol IE Id */
6855 } /* End of for loop for Protocol IE list */
6860 freeAperDecodingOfRicSubsModConfirm(e2apMsg);
6864 /******************************************************************
6865 * @brief Deallocate the memory allocated for E2 Reset Response
6869 * Function : FreeE2ResetResponse
6872 * - freeing the memory allocated for E2ResetResponse
6874 * @params[in] E2AP_PDU_t *e2apMsg
6875 * @return ROK - success
6878 * ****************************************************************/
6879 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
6882 ResetResponseE2_t *resetResponse;
6884 if(e2apMsg != NULLP)
6886 if(e2apMsg->choice.successfulOutcome != NULLP)
6888 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
6889 if(resetResponse->protocolIEs.list.array)
6891 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
6893 if(resetResponse->protocolIEs.list.array[ieIdx])
6895 DU_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
6898 DU_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
6901 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6903 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6907 /*******************************************************************
6909 * @brief Buld and send the E2 Reset Response msg
6913 * Function : BuildAndSendE2ResetResponse
6916 * - Buld and send the E2 Reset Response Message
6918 * @params[in] Trans Id
6919 * @return ROK - success
6922 * ****************************************************************/
6923 uint8_t BuildAndSendResetResponse(uint8_t transId)
6925 uint8_t ieIdx = 0, elementCnt = 0;
6926 uint8_t ret = RFAILED;
6927 E2AP_PDU_t *e2apMsg = NULLP;
6928 ResetResponseE2_t *resetResponse;
6929 asn_enc_rval_t encRetVal; /* Encoder return value */
6931 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
6934 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6935 if(e2apMsg == NULLP)
6937 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
6940 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
6942 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6943 if(e2apMsg->choice.successfulOutcome == NULLP)
6945 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
6949 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
6950 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
6951 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
6952 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
6955 resetResponse->protocolIEs.list.count = elementCnt;
6956 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
6957 DU_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
6958 if(!resetResponse->protocolIEs.list.array)
6960 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
6964 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6966 DU_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
6967 if(!resetResponse->protocolIEs.list.array[ieIdx])
6969 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
6973 if(ieIdx < elementCnt)
6977 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6978 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6979 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
6980 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
6982 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6984 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6986 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6987 if(encRetVal.encoded == ENCODE_FAIL)
6989 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
6990 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6995 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
6996 for(int i=0; i< encBufSize; i++)
6998 DU_LOG("%x",encBuf[i]);
7003 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7005 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
7013 FreeE2ResetResponse(e2apMsg);
7017 /******************************************************************
7019 * @brief Deallocation of memory allocated by aper decoder for reset req
7023 * Function : freeAperDecodingOfE2ResetReq
7025 * Functionality: Deallocation of memory allocated by aper decoder for
7028 * @params[in] Pointer to resetReq
7031 * ****************************************************************/
7032 void freeAperDecodingOfE2ResetReq(ResetRequestE2_t *resetReq)
7038 if(resetReq->protocolIEs.list.array)
7040 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7042 if(resetReq->protocolIEs.list.array[arrIdx])
7044 free(resetReq->protocolIEs.list.array[arrIdx]);
7047 free(resetReq->protocolIEs.list.array);
7052 /*******************************************************************
7054 * @brief Process reset req received from RIC
7058 * Function : procE2ResetRequest
7060 * Functionality: Process reset req received from RIC
7062 * @param E2AP_PDU_t *e2apMsg
7065 ******************************************************************/
7067 void procE2ResetRequest(E2AP_PDU_t *e2apMsg)
7069 uint16_t ranFuncIdx=0;
7070 uint8_t arrIdx =0, transId =0;
7071 ResetRequestE2_t *resetReq;
7073 DU_LOG("\nINFO --> E2AP : E2 Reset request received");
7074 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
7076 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7078 switch(resetReq->protocolIEs.list.array[arrIdx]->id)
7080 case ProtocolIE_IDE2_id_TransactionID:
7082 transId = resetReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
7086 case ProtocolIE_IDE2_id_CauseE2:
7088 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
7090 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
7092 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
7093 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
7100 if(BuildAndSendResetResponse(transId) != ROK)
7102 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
7104 freeAperDecodingOfE2ResetReq(resetReq);
7107 /*******************************************************************
7109 * @brief Free APER decoding of RIC Subscription Modification Refuse
7113 * Function : freeAperDecodingOfRicSubsModRefuse
7115 * Functionality: Free APER decoding of RIC Subscription
7116 * Modification Refuse
7118 * @param E2AP Message PDU
7121 ******************************************************************/
7122 void freeAperDecodingOfRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
7125 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7127 if(e2apMsg && e2apMsg->choice.unsuccessfulOutcome)
7129 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7130 if(ricSubsModRefuse->protocolIEs.list.array)
7132 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7134 if(ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7135 free(ricSubsModRefuse->protocolIEs.list.array[ieIdx]);
7137 free(ricSubsModRefuse->protocolIEs.list.array);
7142 /*******************************************************************
7144 * @brief Process RIC Subscription Modification Refuse Message
7148 * Function : procRicSubscriptionModificationRefuse
7150 * Functionality: Process RIC Subscription Modification Refuse
7151 * Message received from RIC.
7153 * @param E2AP Message PDU
7156 ******************************************************************/
7157 void procRicSubscriptionModificationRefuse(E2AP_PDU_t *e2apMsg)
7160 uint16_t ranFuncId = 0;
7161 RicRequestId ricReqId;
7162 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7163 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
7164 CauseE2_t *cause = NULLP;
7166 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Refuse", __func__);
7171 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
7175 if(!e2apMsg->choice.unsuccessfulOutcome)
7177 DU_LOG("\nERROR --> E2AP : %s: Unsuccessful Outcome in E2AP message is NULL", __func__);
7181 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7182 if(!ricSubsModRefuse->protocolIEs.list.array)
7184 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
7188 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7190 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7192 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
7196 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
7197 switch(ricSubsModRefuseIe->id)
7199 case ProtocolIE_IDE2_id_RICrequestID:
7201 memset(&ricReqId, 0, sizeof(RicRequestId));
7202 ricReqId.requestorId = ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID;
7203 ricReqId.instanceId = ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID;
7207 case ProtocolIE_IDE2_id_RANfunctionID:
7209 ranFuncId = ricSubsModRefuseIe->value.choice.RANfunctionID;
7213 case ProtocolIE_IDE2_id_CauseE2:
7215 DU_LOG("\nDEBUG --> E2AP : %s: RIC subscriptiom modification refused for RIC_Requestor_ID [%d] \
7216 RIC_Instance_ID [%d] RAN_Function_ID [%d] ", __func__, ricReqId.requestorId, \
7217 ricReqId.instanceId, ranFuncId);
7219 cause = &ricSubsModRefuseIe->value.choice.CauseE2;
7220 printE2ErrorCause(cause);
7225 } /* End of switch for Protocol IE Id */
7226 } /* End of for loop for Protocol IE list */
7231 freeAperDecodingOfRicSubsModRefuse(e2apMsg);
7235 /*******************************************************************
7237 * @brief Free RIC Subscription Delete Required Message
7241 * Function : FreeRicSubscriptionDeleteRequired
7243 * Functionality: Free RIC Subscription Delete Required
7245 * @param E2AP Message PDU
7248 ******************************************************************/
7249 void FreeRicSubscriptionDeleteRequired(E2AP_PDU_t *e2apMsg, CmLListCp *ricSubsToBeDelList)
7251 uint8_t ieIdx = 0, arrIdx = 0;
7252 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7253 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7254 RICsubscription_List_withCause_t *ricSubsList = NULLP;
7255 CmLList *subsNode = NULLP;
7259 if(e2apMsg->choice.initiatingMessage)
7261 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7262 if(ricSubsDelRqd->protocolIEs.list.array)
7264 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
7266 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx])
7268 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7269 switch(ricSubsDelRqdIe->id)
7271 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
7273 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
7274 if(ricSubsList->list.array)
7276 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
7278 DU_FREE(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7280 DU_FREE(ricSubsList->list.array, ricSubsList->list.size);
7285 DU_FREE(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7288 DU_FREE(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7290 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7292 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7295 if(ricSubsToBeDelList)
7297 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7300 cmLListDelFrm(ricSubsToBeDelList, subsNode);
7301 DU_FREE(subsNode, sizeof(CmLList));
7302 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7307 /*******************************************************************
7309 * @brief Fill list of RIC subscriptions required to be deleted
7310 * with the cause of deletion
7314 * Function : fillRicSubsListWithCause
7316 * Functionality: Fill list of RIC subscriptions required to be
7317 * deleted with the cause of deletion
7319 * @param E2AP Message PDU
7322 ******************************************************************/
7323 uint8_t fillRicSubsListWithCause(RICsubscription_List_withCause_t *ricSubsList, CmLListCp ricSubsToBeDelList)
7326 CmLList *subsNode = NULLP;
7327 RicSubscription *subsInfo = NULLP;
7328 RICsubscription_withCause_ItemIEs_t *subsItemIe = NULLP;
7329 RICsubscription_withCause_Item_t *subsItem = NULLP;
7331 ricSubsList->list.count = ricSubsToBeDelList.count;
7332 ricSubsList->list.size = ricSubsList->list.count * sizeof(RICsubscription_withCause_ItemIEs_t *);
7333 DU_ALLOC(ricSubsList->list.array, ricSubsList->list.size);
7334 if(!ricSubsList->list.array)
7336 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7340 CM_LLIST_FIRST_NODE(&ricSubsToBeDelList, subsNode);
7341 while(subsNode && (ieIdx < ricSubsList->list.count))
7343 subsInfo = (RicSubscription *)subsNode->node;
7344 DU_ALLOC(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7345 if(!ricSubsList->list.array[ieIdx])
7347 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7351 subsItemIe = (RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[ieIdx];
7352 subsItemIe->id = ProtocolIE_IDE2_id_RICsubscription_withCause_Item;
7353 subsItemIe->criticality = CriticalityE2_ignore;
7354 subsItemIe->value.present = RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item;
7356 subsItem = & subsItemIe->value.choice.RICsubscription_withCause_Item;
7357 subsItem->ricRequestID.ricRequestorID = subsInfo->requestId.requestorId;
7358 subsItem->ricRequestID.ricInstanceID = subsInfo->requestId.instanceId;
7359 subsItem->ranFunctionID = subsInfo->ranFuncId;
7360 fillE2Cause(&subsItem->cause, subsInfo->failureCause);
7363 subsNode = subsNode->next;
7369 /*******************************************************************
7371 * @brief Builds and Send RIC Subscription delete required
7375 * Function : BuildAndSendRicSubscriptionDeleteRequired
7377 * Functionality: Build and send RIC subscription delete required.
7378 * There can be 2 approaches to trigger following. One of these
7379 * approaches may/may not be implemented in future:
7380 * 1. It can be triggerred immediately when a RIC subscription's
7381 * End Time has expired. In this case, only this subscription's
7382 * info will be sent in this message.
7383 * Since we have not yet added support to execute RIC
7384 * Subscription based on Start Time and End Timer, this message is
7385 * not triggered anywhere from DU APP yet.
7386 * 2. Another approach is to have a periodic timer to check subscription
7387 * status running in background.
7388 * When RIC Subscription End Time expires, this subscription is
7389 * marked to be deleted. Later when this background timer expires,
7390 * a RIC Subscription delete required is sent with all the
7391 * subscription's info which is marked to be deleted.
7392 * The following function is implemented keeping in mind the second
7396 * @return ROK - success
7399 ******************************************************************/
7400 uint8_t BuildAndSendRicSubscriptionDeleteRequired()
7402 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7403 E2AP_PDU_t *e2apMsg = NULLP;
7404 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7405 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7406 asn_enc_rval_t encRetVal; /* Encoder return value */
7407 CmLListCp ricSubsToBeDelList;
7411 /* Check if there are any RIC subscriptions to be deleted */
7412 cmLListInit(&ricSubsToBeDelList);
7413 fetchRicSubsToBeDeleted(&ricSubsToBeDelList);
7414 if(ricSubsToBeDelList.count == 0)
7416 DU_LOG("\nDEBUG --> E2AP : %s: No RIC subscriptions are required to be deleted", __func__);
7420 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Required Message\n");
7422 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7423 if(e2apMsg == NULLP)
7425 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7429 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
7430 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7431 if(e2apMsg->choice.initiatingMessage == NULLP)
7433 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7436 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDeleteRequired;
7437 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
7438 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired;
7440 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7443 ricSubsDelRqd->protocolIEs.list.count = elementCnt;
7444 ricSubsDelRqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequired_IEs_t *);
7446 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7447 if(ricSubsDelRqd->protocolIEs.list.array == NULLP)
7449 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7453 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7455 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7456 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx] == NULLP)
7458 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7459 __func__, ieIdx, __LINE__);
7463 if(ieIdx < elementCnt)
7467 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7468 ricSubsDelRqdIe->id = ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved;
7469 ricSubsDelRqdIe->criticality = CriticalityE2_ignore;
7470 ricSubsDelRqdIe->value.present = RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause;
7471 if(fillRicSubsListWithCause(&ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause, ricSubsToBeDelList)\
7474 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription list with cause", __func__);
7478 /* Prints the Msg formed */
7479 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7480 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7482 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7483 if(encRetVal.encoded == ENCODE_FAIL)
7485 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Required Message (at %s)\n",\
7486 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7491 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Required Message \n");
7492 #ifdef DEBUG_ASN_PRINT
7493 for(int i=0; i< encBufSize; i++)
7495 printf("%x",encBuf[i]);
7500 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7502 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Required Message");
7509 FreeRicSubscriptionDeleteRequired(e2apMsg, &ricSubsToBeDelList);
7513 /*******************************************************************
7515 * @brief Free RIC Subscription Delete Failure Message
7519 * Function : FreeRicSubscriptionDeleteFailure
7521 * Functionality: Free RIC Subscription Delete Failure
7523 * @param E2AP Message PDU
7526 ******************************************************************/
7527 void FreeRicSubscriptionDeleteFailure(E2AP_PDU_t *e2apMsg)
7530 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7534 if(e2apMsg->choice.unsuccessfulOutcome)
7536 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7537 if(ricSubsDelFailure->protocolIEs.list.array)
7539 for(ieIdx = 0; ieIdx < ricSubsDelFailure->protocolIEs.list.count; ieIdx++)
7541 DU_FREE(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7543 DU_FREE(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7545 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7547 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7551 /*******************************************************************
7553 * @brief Builds and Send RIC Subscription Delete Failure
7557 * Function : BuildAndSendRicSubscriptionDeleteFailure
7559 * Functionality: Build and send RIC Subscription Delete Failure.
7565 * @return ROK - success
7568 ******************************************************************/
7569 uint8_t BuildAndSendRicSubscriptionDeleteFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
7571 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7572 E2AP_PDU_t *e2apMsg = NULLP;
7573 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7574 RICsubscriptionDeleteFailure_IEs_t *ricSubsDelFailureIe = NULLP;
7575 asn_enc_rval_t encRetVal; /* Encoder return value */
7579 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Failure Message\n");
7581 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7582 if(e2apMsg == NULLP)
7584 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7588 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
7589 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7590 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
7592 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7595 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7596 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
7597 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteFailure;
7600 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7603 ricSubsDelFailure->protocolIEs.list.count = elementCnt;
7604 ricSubsDelFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteFailure_IEs_t *);
7606 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7607 if(ricSubsDelFailure->protocolIEs.list.array == NULLP)
7609 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7613 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7615 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7616 if(ricSubsDelFailure->protocolIEs.list.array[ieIdx] == NULLP)
7618 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7619 __func__, ieIdx, __LINE__);
7623 if(ieIdx < elementCnt)
7627 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7628 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
7629 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7630 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
7631 ricSubsDelFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7632 ricSubsDelFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7635 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7636 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7637 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7638 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
7639 ricSubsDelFailureIe->value.choice.RANfunctionID = ranFuncId;
7642 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
7643 ricSubsDelFailureIe->criticality = CriticalityE2_ignore;
7644 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_CauseE2;
7645 fillE2Cause(&ricSubsDelFailureIe->value.choice.CauseE2, failureCause);
7647 /* Prints the Msg formed */
7648 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7649 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7651 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7652 if(encRetVal.encoded == ENCODE_FAIL)
7654 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Failure Message (at %s)\n",\
7655 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7660 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Failure Message \n");
7661 #ifdef DEBUG_ASN_PRINT
7662 for(int i=0; i< encBufSize; i++)
7664 printf("%x",encBuf[i]);
7669 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7671 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Failure Message");
7679 FreeRicSubscriptionDeleteFailure(e2apMsg);
7684 /*******************************************************************
7686 * @brief Free RIC Subscription Delete Response Message
7690 * Function : FreeRicSubscriptionDeleteResponse
7692 * Functionality: Free RIC Subscription Delete Response
7694 * @param E2AP Message PDU
7697 ******************************************************************/
7698 void FreeRicSubscriptionDeleteResponse(E2AP_PDU_t *e2apMsg)
7701 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7705 if(e2apMsg->choice.successfulOutcome)
7707 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7708 if(ricSubsDelRsp->protocolIEs.list.array)
7710 for(ieIdx = 0; ieIdx < ricSubsDelRsp->protocolIEs.list.count; ieIdx++)
7712 DU_FREE(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7714 DU_FREE(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7716 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7718 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7722 /*******************************************************************
7724 * @brief Builds and Send RIC Subscription delete Response
7728 * Function : BuildAndSendRicSubscriptionDeleteResponse
7730 * Functionality: Build and send RIC subscription delete Response.
7735 * @return ROK - success
7738 ******************************************************************/
7739 uint8_t BuildAndSendRicSubscriptionDeleteResponse(uint16_t ranFuncId, RicRequestId requestId)
7741 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7742 E2AP_PDU_t *e2apMsg = NULLP;
7743 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7744 RICsubscriptionDeleteResponse_IEs_t *ricSubsDelRspIe = NULLP;
7745 asn_enc_rval_t encRetVal; /* Encoder return value */
7749 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Response Message\n");
7751 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7752 if(e2apMsg == NULLP)
7754 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7758 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7759 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7760 if(e2apMsg->choice.successfulOutcome == NULLP)
7762 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7765 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7766 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7767 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse;
7770 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7773 ricSubsDelRsp->protocolIEs.list.count = elementCnt;
7774 ricSubsDelRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteResponse_IEs_t *);
7776 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7777 if(ricSubsDelRsp->protocolIEs.list.array == NULLP)
7779 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7783 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7785 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7786 if(ricSubsDelRsp->protocolIEs.list.array[ieIdx] == NULLP)
7788 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7789 __func__, ieIdx, __LINE__);
7793 if(ieIdx < elementCnt)
7797 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7798 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
7799 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7800 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
7801 ricSubsDelRspIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7802 ricSubsDelRspIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7805 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7806 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7807 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7808 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
7809 ricSubsDelRspIe->value.choice.RANfunctionID = ranFuncId;
7811 /* Prints the Msg formed */
7812 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7813 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7815 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7816 if(encRetVal.encoded == ENCODE_FAIL)
7818 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Response Message (at %s)\n",\
7819 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7824 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Response Message \n");
7825 #ifdef DEBUG_ASN_PRINT
7826 for(int i=0; i< encBufSize; i++)
7828 printf("%x",encBuf[i]);
7833 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7835 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Response Message");
7843 FreeRicSubscriptionDeleteResponse(e2apMsg);
7847 /*******************************************************************
7849 * @brief Free RIC Subscription Delete Request Message
7853 * Function : freeAperDecodingOfRicSubsDeleteReq
7855 * Functionality: Free RIC Subscription Delete Request
7857 * @param E2AP Message PDU
7860 ******************************************************************/
7861 void freeAperDecodingOfRicSubsDeleteReq(E2AP_PDU_t *e2apMsg)
7864 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
7868 if(e2apMsg->choice.initiatingMessage)
7870 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
7871 if(ricSubsDelReq->protocolIEs.list.array)
7873 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
7875 if(ricSubsDelReq->protocolIEs.list.array[ieIdx])
7877 free(ricSubsDelReq->protocolIEs.list.array[ieIdx]);
7880 free(ricSubsDelReq->protocolIEs.list.array);
7886 /*******************************************************************
7888 * @brief Process RIC Subscription delete request
7892 * Function : procRicSubscriptionDeleteRequest
7894 * Functionality: Process RIC subscription delete request.
7895 * Fetch RAN Function and RIC subscription to be deleted.
7896 * Send statistics delete request to MAC for all action sequence
7897 * within this RIC subscription.
7899 * @params[in] E2AP PDU
7902 ******************************************************************/
7903 void procRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
7906 uint16_t ranFuncId = 0;
7907 bool procFailure = false;
7908 RicRequestId ricReqId;
7909 RanFunction *ranFuncDb = NULLP;
7910 CmLList *ricSubsNode = NULLP;
7911 RicSubscription *ricSubsDb = NULLP;
7912 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
7913 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
7915 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Delete Request", __func__);
7920 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
7924 if(!e2apMsg->choice.initiatingMessage)
7926 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
7930 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
7931 if(!ricSubsDelReq->protocolIEs.list.array)
7933 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
7937 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
7939 if(!ricSubsDelReq->protocolIEs.list.array[ieIdx])
7941 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
7945 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
7946 switch(ricSubsDelReqIe->id)
7948 case ProtocolIE_IDE2_id_RICrequestID:
7950 memset(&ricReqId, 0, sizeof(RicRequestId));
7951 ricReqId.requestorId = ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID;
7952 ricReqId.instanceId = ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID;
7956 case ProtocolIE_IDE2_id_RANfunctionID:
7958 ranFuncId = ricSubsDelReqIe->value.choice.RANfunctionID;
7959 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
7962 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
7967 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
7970 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
7971 __func__, ricReqId.requestorId, ricReqId.instanceId);
7976 if(BuildAndSendStatsDeleteReq(ricSubsDb) != ROK)
7978 DU_LOG("\nERROR --> E2AP : Failed to build and send ric subscription delete req to du layers");
7985 } /* End of switch for Protocol IE Id */
7989 } /* End of for loop for Protocol IE list */
7994 freeAperDecodingOfRicSubsDeleteReq(e2apMsg);
7998 /*******************************************************************
8000 * @brief Deallocate the memory allocated for E2 node configuration
8001 * update ack msg by aper decoder
8005 * Function : freeAperDecodingOfE2NodeConfigUpdateAck
8008 * - Deallocate the memory allocated for E2 node configuration
8009 * update ack msg by aper decoder
8011 * @params[in] E2AP_PDU_t *e2apMsg
8012 * @return ROK - success
8015 * ****************************************************************/
8017 void freeAperDecodingOfE2NodeConfigUpdateAck(E2nodeConfigurationUpdateAcknowledge_t *updateAckMsg)
8019 uint8_t arrIdx =0, e2NodeConfigIdx=0;
8020 E2nodeComponentConfigUpdateAck_ItemIEs_t *updateAckItemIe=NULL;
8021 E2nodeComponentConfigUpdateAck_List_t *updateAckList=NULL;
8022 E2nodeComponentConfigRemovalAck_ItemIEs_t *removalAckItemIe=NULL;
8023 E2nodeComponentConfigRemovalAck_List_t *removalAckList=NULL;
8024 E2nodeComponentConfigAdditionAck_ItemIEs_t *additionAckItemIte=NULL;
8025 E2nodeComponentConfigAdditionAck_List_t *additionAckList=NULL;
8027 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULLP;
8028 if(updateAckMsg->protocolIEs.list.array != NULLP)
8030 for(arrIdx = 0; arrIdx < updateAckMsg->protocolIEs.list.count; arrIdx++)
8032 if(updateAckMsg->protocolIEs.list.array[arrIdx])
8034 switch(updateAckMsg->protocolIEs.list.array[arrIdx]->id)
8036 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8038 additionAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8039 if(additionAckList->list.array)
8041 for(e2NodeConfigIdx=0; e2NodeConfigIdx<additionAckList->list.count; e2NodeConfigIdx++)
8043 additionAckItemIte = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) additionAckList->list.array[e2NodeConfigIdx];
8044 if(additionAckItemIte)
8046 switch(additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present)
8048 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8050 f1InterfaceInfo = additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8051 free(f1InterfaceInfo->gNB_DU_ID.buf);
8052 free(f1InterfaceInfo);
8058 free(additionAckItemIte);
8060 free(additionAckList->list.array);
8065 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8067 updateAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8068 if(updateAckList->list.array)
8070 for(e2NodeConfigIdx=0; e2NodeConfigIdx<updateAckList->list.count; e2NodeConfigIdx++)
8072 updateAckItemIe = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) updateAckList->list.array[e2NodeConfigIdx];
8075 switch(updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.present)
8077 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8079 f1InterfaceInfo = updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8080 free(f1InterfaceInfo->gNB_DU_ID.buf);
8081 free(f1InterfaceInfo);
8087 free(updateAckItemIe);
8090 free(updateAckList->list.array);
8094 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8096 removalAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8097 if(removalAckList->list.array)
8099 for(e2NodeConfigIdx=0; e2NodeConfigIdx<removalAckList->list.count; e2NodeConfigIdx++)
8101 removalAckItemIe = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) removalAckList->list.array[e2NodeConfigIdx];
8102 if(removalAckItemIe)
8104 switch(removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.present)
8106 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8108 f1InterfaceInfo = removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8109 free(f1InterfaceInfo->gNB_DU_ID.buf);
8110 free(f1InterfaceInfo);
8116 free(removalAckItemIe);
8119 free(removalAckList->list.array);
8124 free(updateAckMsg->protocolIEs.list.array[arrIdx]);
8127 free(updateAckMsg->protocolIEs.list.array);
8131 /******************************************************************
8133 * @brief Processes the E2 node config update ack msg
8137 * Function :procE2NodeConfigUpdateAck
8139 * Functionality: Processes the E2 node config update ack msg
8141 * @params[in] E2AP_PDU_t ASN decoded E2AP message
8142 * @return ROK - success
8145 * ****************************************************************/
8147 void procE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
8150 uint16_t e2CfgIdx =0;
8151 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck =NULLP;
8152 E2nodeComponentConfigUpdateAck_List_t *e2NodeConfigUpdateAckList=NULLP;
8153 E2nodeComponentConfigUpdateAck_ItemIEs_t *e2NodeUpdateAckItem=NULLP;
8154 E2nodeComponentConfigRemovalAck_List_t *e2NodeConfigRemovalAckList=NULLP;
8155 E2nodeComponentConfigRemovalAck_ItemIEs_t *e2NodeRemovalAckItem=NULLP;
8156 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULLP;
8157 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAdditionAckItem=NULLP;
8159 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
8161 if(e2NodeConfigUpdateAck->protocolIEs.list.array)
8163 for(arrIdx =0; arrIdx<e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
8165 switch(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id)
8167 case ProtocolIE_IDE2_id_TransactionID:
8171 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8173 e2NodeConfigAdditionAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8174 if(e2NodeConfigAdditionAckList->list.array)
8176 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigAdditionAckList->list.count; e2CfgIdx++)
8178 e2NodeAdditionAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2CfgIdx];
8179 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAdditionAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
8180 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
8185 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8187 e2NodeConfigUpdateAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8188 if(e2NodeConfigUpdateAckList->list.array)
8190 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigUpdateAckList->list.count; e2CfgIdx++)
8192 e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[e2CfgIdx];
8193 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeUpdateAckItem->value.choice.E2nodeComponentConfigUpdateAck_Item,\
8194 ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck);
8199 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8201 e2NodeConfigRemovalAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8202 if(e2NodeConfigRemovalAckList->list.array)
8204 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigRemovalAckList->list.count; e2CfgIdx++)
8206 e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[e2CfgIdx];
8207 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeRemovalAckItem->value.choice.E2nodeComponentConfigRemovalAck_Item,\
8208 ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck);
8217 freeAperDecodingOfE2NodeConfigUpdateAck(e2NodeConfigUpdateAck);
8220 /*******************************************************************
8222 * @brief Deallocate the memory allocated for RemovalRequest msg
8226 * Function : FreeRemovalRequest
8229 * - freeing the memory allocated for RemovalRequest
8231 * @params[in] E2AP_PDU_t *e2apMsg
8232 * @return ROK - success
8235 * ****************************************************************/
8236 void FreeRemovalRequest(E2AP_PDU_t *e2apMsg)
8239 E2RemovalRequest_t *removalReq = NULLP;
8241 if(e2apMsg != NULLP)
8243 if(e2apMsg->choice.initiatingMessage != NULLP)
8245 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8246 if(removalReq->protocolIEs.list.array)
8248 for(ieIdx = 0; ieIdx < removalReq->protocolIEs.list.count; ieIdx++)
8250 DU_FREE(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8252 DU_FREE(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8254 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8256 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8260 /*******************************************************************
8262 * @brief Build and send the removal request msg
8266 * Function : BuildAndSendRemovalRequest
8269 * - Buld and send the removal request msg to E2 node
8271 * @return ROK - success
8274 * ****************************************************************/
8276 uint8_t BuildAndSendRemovalRequest()
8278 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
8279 uint8_t ret = RFAILED;
8280 E2AP_PDU_t *e2apMsg = NULLP;
8281 E2RemovalRequest_t *removalReq = NULLP;
8282 asn_enc_rval_t encRetVal; /* Encoder return value */
8284 DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
8288 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8289 if(e2apMsg == NULLP)
8291 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8295 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
8296 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8297 if(e2apMsg->choice.initiatingMessage == NULLP)
8299 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8303 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2removal;
8304 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
8305 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2RemovalRequest;
8306 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8309 removalReq->protocolIEs.list.count = elementCnt;
8310 removalReq->protocolIEs.list.size = elementCnt * sizeof(E2RemovalRequestIEs_t *);
8312 DU_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8313 if(!removalReq->protocolIEs.list.array)
8315 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8319 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
8321 DU_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8322 if(!removalReq->protocolIEs.list.array[ieIdx])
8324 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8329 /* In case of failure */
8330 if(ieIdx < elementCnt)
8334 removalReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8335 removalReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8336 removalReq->protocolIEs.list.array[ieIdx]->value.present = E2RemovalRequestIEs__value_PR_TransactionID;
8337 transId = assignTransactionId();
8338 removalReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8340 /* Prints the Msg formed */
8341 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8343 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8345 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
8347 if(encRetVal.encoded == ENCODE_FAIL)
8349 DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
8350 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8355 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
8356 #ifdef DEBUG_ASN_PRINT
8357 for(int i=0; i< encBufSize; i++)
8359 printf("%x",encBuf[i]);
8363 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8365 DU_LOG("\nERROR --> E2AP : Sending removal request failed");
8371 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
8372 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
8376 /* Free all memory */
8377 FreeRemovalRequest(e2apMsg);
8382 /******************************************************************
8384 * @brief Deallocation of memory allocated by aper decoder
8385 * for Removal failure
8389 * Function : freeAperDecodingOfE2RemovalFailure
8391 * Functionality: Deallocation of memory allocated by aper decoder
8392 * for Removal failure
8394 * @params[in] Pointer to removalFailure
8397 * ****************************************************************/
8398 void freeAperDecodingOfE2RemovalFailure(E2RemovalFailure_t *removalFailure)
8404 if(removalFailure->protocolIEs.list.array)
8406 for(arrIdx=0; arrIdx<removalFailure->protocolIEs.list.count; arrIdx++)
8408 if(removalFailure->protocolIEs.list.array[arrIdx])
8410 free(removalFailure->protocolIEs.list.array[arrIdx]);
8413 free(removalFailure->protocolIEs.list.array);
8418 /******************************************************************
8420 * @brief Processes the E2 removal failure msg
8424 * Function : procE2RemovalFailure
8426 * Functionality: Processes the E2 removal failure msg
8429 * E2AP_PDU_t *e2apMsg
8433 * ****************************************************************/
8434 void ProcE2RemovalFailure(E2AP_PDU_t *e2apMsg)
8436 uint8_t ieIdx = 0, transId=0;
8437 CauseE2_t *cause = NULLP;
8438 E2RemovalFailure_t *e2RemovalFailure=NULLP;
8440 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
8442 if(!e2RemovalFailure->protocolIEs.list.array)
8444 DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
8448 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
8450 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
8452 switch(e2RemovalFailure->protocolIEs.list.array[ieIdx]->id)
8454 case ProtocolIE_IDE2_id_TransactionID:
8456 transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8457 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8458 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8460 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8464 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8468 case ProtocolIE_IDE2_id_CauseE2:
8470 cause = &e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
8471 printE2ErrorCause(cause);
8476 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
8482 freeAperDecodingOfE2RemovalFailure(e2RemovalFailure);
8485 /******************************************************************
8487 * @brief Deallocation of memory allocated by aper decoder
8488 * for Removal failure
8492 * Function : freeAperDecodingOfE2RemovalResponse
8494 * Functionality: Deallocation of memory allocated by aper decoder
8495 * for Removal failure
8497 * @params[in] Pointer to removalResponse
8500 * ****************************************************************/
8501 void freeAperDecodingOfE2RemovalResponse(E2RemovalResponse_t *removalResponse)
8507 if(removalResponse->protocolIEs.list.array)
8509 for(arrIdx=0; arrIdx<removalResponse->protocolIEs.list.count; arrIdx++)
8511 if(removalResponse->protocolIEs.list.array[arrIdx])
8513 free(removalResponse->protocolIEs.list.array[arrIdx]);
8516 free(removalResponse->protocolIEs.list.array);
8521 /*******************************************************************
8523 * @brief process the E2 Removal Response
8527 * Function : ProcE2RemovalResponse
8529 * Functionality: Process E2 Removal Response
8532 * E2AP_PDU_t *e2apMsg
8535 ******************************************************************/
8537 void ProcE2RemovalResponse(E2AP_PDU_t *e2apMsg)
8539 uint8_t ieIdx = 0, transId=0;
8540 E2RemovalResponse_t *removalRsp = NULLP;
8542 removalRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
8544 if(!removalRsp->protocolIEs.list.array)
8546 DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
8550 for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
8552 if(removalRsp->protocolIEs.list.array[ieIdx])
8554 switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
8556 case ProtocolIE_IDE2_id_TransactionID:
8558 transId = removalRsp->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8559 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8560 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8562 DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
8563 cmInetClose(&ricParams.sockFd);
8564 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8565 removeE2NodeInformation();
8569 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8575 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
8582 freeAperDecodingOfE2RemovalResponse(removalRsp);
8585 /*******************************************************************
8587 * @brief Deallocate the memory allocated for E2 Connection Update Failure
8591 * Function : FreeE2ConnectionUpdateFailure
8594 * - freeing the memory allocated for E2ConnectionUpdateFailure
8596 * @params[in] E2AP_PDU_t *e2apMsg
8597 * @return ROK - success
8600 * ****************************************************************/
8601 void FreeE2ConnectionUpdateFailure(E2AP_PDU_t *e2apMsg)
8604 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8606 if(e2apMsg != NULLP)
8608 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
8610 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8611 if(e2ConnectionUpdateFailure->protocolIEs.list.array)
8613 for(ieIdx=0; ieIdx < e2ConnectionUpdateFailure->protocolIEs.list.count; ieIdx++)
8615 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8617 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8619 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8621 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8625 /*******************************************************************
8627 * @brief Buld and send the E2 Connection Update Failure msg
8631 * Function : BuildAndSendE2ConnectionUpdateFailure
8634 * - Buld and send the E2 Connection Update Failure Message
8638 * @return ROK - success
8641 * ****************************************************************/
8643 uint8_t BuildAndSendE2ConnectionUpdateFailure(uint16_t transId, E2FailureCause failureCause)
8645 uint8_t ieIdx = 0, elementCnt = 0;
8646 uint8_t ret = RFAILED;
8647 E2AP_PDU_t *e2apMsg = NULLP;
8648 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8649 asn_enc_rval_t encRetVal; /* Encoder return value */
8651 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Failure Message\n");
8654 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8655 if(e2apMsg == NULLP)
8657 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8660 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
8662 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8663 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
8665 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8669 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
8670 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
8671 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure;
8672 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8675 e2ConnectionUpdateFailure->protocolIEs.list.count = elementCnt;
8676 e2ConnectionUpdateFailure->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateFailure_IEs_t *);
8677 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8678 if(!e2ConnectionUpdateFailure->protocolIEs.list.array)
8680 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8684 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
8686 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8687 if(!e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx])
8689 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8693 if(ieIdx < elementCnt)
8697 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8698 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8699 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_TransactionID;
8700 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8704 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
8705 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
8706 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_CauseE2;
8707 fillE2Cause(&e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, failureCause);
8709 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8711 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8713 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
8714 if(encRetVal.encoded == ENCODE_FAIL)
8716 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update failure structure (at %s)\n",\
8717 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8722 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Failure \n");
8723 for(int i=0; i< encBufSize; i++)
8725 DU_LOG("%x",encBuf[i]);
8730 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8732 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Failure");
8740 FreeE2ConnectionUpdateFailure(e2apMsg);
8744 /*******************************************************************
8746 * @brief fill E2 connection update item
8750 * Function : fillE2connectionUpdateItem
8752 * Functionality: fill E2 connection update item
8755 * E2connectionUpdate Item to be filled
8759 * @return ROK - success
8761 * ****************************************************************/
8763 uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId, uint32_t ipAddress, AssocUsage usage)
8765 CauseE2_t *cause=NULLP;
8766 TNLusage_t *tnlUsage=NULLP;
8767 E2FailureCause failureCause;
8768 TNLinformation_t *tnlInformation = NULLP;
8769 E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
8770 E2connectionSetupFailed_Item_t *connectionRemoveITem=NULLP;
8774 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8776 connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
8777 tnlInformation = &connectionModifyItem->tnlInformation;
8778 tnlUsage = &connectionModifyItem->tnlUsage;
8782 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8784 connectionRemoveITem = (E2connectionSetupFailed_Item_t*)connectionInfo;
8785 tnlInformation= &connectionRemoveITem->tnlInformation;
8786 cause = &connectionRemoveITem->cause;
8793 tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
8794 DU_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
8795 if(!tnlInformation->tnlAddress.buf)
8797 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8801 tnlInformation->tnlAddress.buf[3] = ipAddress & 0xFF;
8802 tnlInformation->tnlAddress.buf[2] = (ipAddress>> 8) & 0xFF;
8803 tnlInformation->tnlAddress.buf[1] = (ipAddress>> 16) & 0xFF;
8804 tnlInformation->tnlAddress.buf[0] = (ipAddress>> 24) & 0xFF;
8805 tnlInformation->tnlAddress.bits_unused = 0;
8809 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8814 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8816 failureCause.causeType = E2_TRANSPORT;
8817 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
8818 fillE2Cause(cause, failureCause);
8828 /*******************************************************************
8830 * @brief Build E2 connection modification list
8834 * Function :BuildE2ConnectionUpdateList
8836 * Functionality: Build E2 connection modification list
8839 * E2 connection update list to be filled
8840 * Count of E2 connection to be added in the list
8841 * Received list of E2 connection
8843 * @return ROK - success
8845 * ****************************************************************/
8847 uint8_t BuildE2ConnectionUpdateList(E2connectionUpdate_List_t *connectionSetupList, uint8_t count, E2ConnectionItem *tmpConnectionList)
8850 E2connectionUpdate_ItemIEs_t *connectionSetupItem=NULLP;
8852 connectionSetupList->list.count = count;
8854 connectionSetupList->list.size = connectionSetupList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
8855 DU_ALLOC(connectionSetupList->list.array, connectionSetupList->list.size);
8856 if(connectionSetupList->list.array)
8858 for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
8860 DU_ALLOC(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
8861 if(connectionSetupList->list.array[arrIdx] == NULLP)
8863 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8866 connectionSetupItem = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
8867 connectionSetupItem->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
8868 connectionSetupItem->criticality= CriticalityE2_ignore;
8869 connectionSetupItem->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
8870 if(fillE2connectionUpdateItem((PTR)&connectionSetupItem->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item,\
8871 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
8873 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
8881 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8887 /*******************************************************************
8889 * @brief Build E2 connection setup failed list
8893 * Function : BuildE2ConnectionSetupFailedList
8895 * Functionality: Build E2 connection setup failed list
8898 * E2 connection setup failed list to be filled
8899 * Count of E2 connection to be added in the list
8900 * Received list of E2 connection
8902 * @return ROK - success
8904 * ****************************************************************/
8906 uint8_t BuildE2ConnectionSetupFailedList(E2connectionSetupFailed_List_t *setupFailedList, uint8_t count, E2ConnectionItem *tmpConnectionList)
8909 E2connectionSetupFailed_ItemIEs_t *setupFailedItem=NULLP;
8911 setupFailedList->list.count = 1;
8913 setupFailedList->list.size = setupFailedList->list.count*sizeof(E2connectionSetupFailed_ItemIEs_t *);
8914 DU_ALLOC(setupFailedList->list.array, setupFailedList->list.size);
8915 if(setupFailedList->list.array)
8917 for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
8919 DU_ALLOC(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
8920 if(setupFailedList->list.array[arrIdx] == NULLP)
8922 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8925 setupFailedItem = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
8926 setupFailedItem->id = ProtocolIE_IDE2_id_E2connectionSetupFailed_Item;
8927 setupFailedItem->criticality= CriticalityE2_ignore;
8928 setupFailedItem->value.present = E2connectionSetupFailed_ItemIEs__value_PR_E2connectionSetupFailed_Item;
8929 if(fillE2connectionUpdateItem((PTR)&setupFailedItem->value.choice.E2connectionSetupFailed_Item, ProtocolIE_IDE2_id_E2connectionSetupFailed_Item,\
8930 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
8932 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection failed to update item");
8940 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8946 /*******************************************************************
8948 * @brief Deallocate the memory allocated for E2 Connection
8953 * Function :FreeE2ConnectionUpdateAcknowledge
8956 * - freeing the memory allocated for E2 Connection
8959 * @params[in] E2AP_PDU_t *e2apMsg
8960 * @return ROK - success
8963 * ****************************************************************/
8965 void FreeE2ConnectionUpdateAcknowledge(E2AP_PDU_t *e2apMsg)
8967 uint8_t ieIdx =0, arrIdx=0;
8968 E2connectionUpdateAcknowledge_t *connectionUpdate = NULLP;
8969 E2connectionUpdate_List_t *connectionSetupList = NULLP;
8970 E2connectionSetupFailed_List_t *setupFailedList = NULLP;
8972 if(e2apMsg != NULLP)
8974 if(e2apMsg->choice.successfulOutcome != NULLP)
8976 connectionUpdate = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
8977 if(connectionUpdate->protocolIEs.list.array)
8979 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
8981 if(connectionUpdate->protocolIEs.list.array[ieIdx])
8983 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
8985 case ProtocolIE_IDE2_id_TransactionID:
8988 case ProtocolIE_IDE2_id_E2connectionSetup:
8990 connectionSetupList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
8991 if(connectionSetupList->list.array)
8993 for(arrIdx = 0; arrIdx < connectionSetupList->list.count; arrIdx++)
8995 DU_FREE(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
8997 DU_FREE(connectionSetupList->list.array, connectionSetupList->list.size);
9002 case ProtocolIE_IDE2_id_E2connectionSetupFailed:
9004 setupFailedList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
9005 if(setupFailedList->list.array)
9007 for(arrIdx = 0; arrIdx < setupFailedList->list.count; arrIdx++)
9009 DU_FREE(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9011 DU_FREE(setupFailedList->list.array, setupFailedList->list.size);
9016 DU_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9019 DU_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
9021 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9023 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
9027 /*******************************************************************
9029 * @brief Buld and send the E2 Connection Update Acknowledge msg
9033 * Function : BuildAndSendE2ConnectionUpdateAcknowledge
9036 * - Buld and send the E2 Connection Update Acknowledge Message
9039 * List of E2 connection needs to fill in IE
9040 * @return ROK - success
9043 * ****************************************************************/
9045 uint8_t BuildAndSendE2ConnectionUpdateAcknowledge(uint16_t transId, E2ConnectionList connectionInfoList)
9047 uint8_t ieIdx = 0, elementCnt = 0;
9048 uint8_t ret = RFAILED;
9049 E2AP_PDU_t *e2apMsg = NULLP;
9050 asn_enc_rval_t encRetVal;
9051 E2connectionUpdateAcknowledge_t *e2ConnectionUpdateAcknowledge=NULLP;
9053 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Acknowledge Message\n");
9056 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
9057 if(e2apMsg == NULLP)
9059 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9062 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
9064 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9065 if(e2apMsg->choice.successfulOutcome == NULLP)
9067 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9071 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
9072 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
9073 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge;
9074 e2ConnectionUpdateAcknowledge = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9077 if(connectionInfoList.numOfE2ConnectionSetup)
9079 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9082 e2ConnectionUpdateAcknowledge->protocolIEs.list.count = elementCnt;
9083 e2ConnectionUpdateAcknowledge->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateAck_IEs_t*);
9084 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array, e2ConnectionUpdateAcknowledge->protocolIEs.list.size);
9085 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array)
9087 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9091 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
9093 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9094 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx])
9096 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9100 if(ieIdx < elementCnt)
9104 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
9105 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9106 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_TransactionID;
9107 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
9109 if(connectionInfoList.numOfE2ConnectionSetup)
9112 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetup;
9113 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9114 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionUpdate_List;
9115 if(BuildE2ConnectionUpdateList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List, \
9116 connectionInfoList.numOfE2ConnectionSetup, connectionInfoList.setupE2Connection) != ROK)
9118 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection setup list");
9123 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9126 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetupFailed;
9127 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9128 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionSetupFailed_List;
9129 if(BuildE2ConnectionSetupFailedList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List, \
9130 connectionInfoList.numOfE2ConnectionFailedToSetup, connectionInfoList.failedToSetupE2Connection) != ROK)
9132 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection failed to setup list");
9137 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
9139 memset(encBuf, 0, ENC_BUF_MAX_LEN);
9141 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
9142 if(encRetVal.encoded == ENCODE_FAIL)
9144 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update acknowledge failure structure (at %s)\n",\
9145 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9150 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Acknowledge \n");
9151 for(int i=0; i< encBufSize; i++)
9153 DU_LOG("%x",encBuf[i]);
9158 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
9160 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Acknowledge");
9168 FreeE2ConnectionUpdateAcknowledge(e2apMsg);
9172 /******************************************************************
9174 * @brief Deallocation of memory allocated by aper decoder for
9175 * E2 Connection Update
9179 * Function :freeAperDecodingOfE2ConnectionUpdate
9181 * Functionality: Deallocation of memory allocated by aper decoder for
9182 * E2 Connection Update
9184 * @params[in] Pointer to connectionUpdate
9187 * ****************************************************************/
9189 void freeAperDecodingOfE2ConnectionUpdate(E2connectionUpdate_t *connectionUpdate)
9191 uint8_t ieIdx =0, arrIdx=0;
9192 E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
9193 E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
9195 if(connectionUpdate->protocolIEs.list.array)
9197 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9199 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9201 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9203 case ProtocolIE_IDE2_id_TransactionID:
9206 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9208 connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9209 if(connectionToBeModifyList->list.array)
9211 for(arrIdx= 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
9213 free(connectionToBeModifyList->list.array[arrIdx]);
9215 free(connectionToBeModifyList->list.array);
9219 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9221 connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
9222 if(connectionToBeRemoveList->list.array)
9224 for(arrIdx= 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
9226 free(connectionToBeRemoveList->list.array[arrIdx]);
9228 free(connectionToBeRemoveList->list.array);
9233 free(connectionUpdate->protocolIEs.list.array[ieIdx]);
9236 free(connectionUpdate->protocolIEs.list.array);
9240 /*******************************************************************
9242 * @brief Handling of E2 connection modification Ie
9246 * Function : handleE2ConnectionModification
9248 * Functionality: Handling of E2 connection modification Ie
9251 * E2 Connection update list
9252 * E2 connection list which needs to be filled
9255 ******************************************************************/
9257 void handleE2ConnectionModification(E2connectionUpdate_List_t *connectionUpdateList, E2ConnectionList *connectionInfoList)
9259 uint32_t ipAddress=0;
9260 bool infoFound = false;
9261 uint8_t arrIdx=0,idx=0, count =0;
9262 E2connectionUpdate_ItemIEs_t *connectionModifyItem=NULLP;
9264 if(connectionUpdateList->list.array)
9266 for(arrIdx = 0; arrIdx < connectionUpdateList->list.count; arrIdx++)
9268 connectionModifyItem= (E2connectionUpdate_ItemIEs_t*)connectionUpdateList->list.array[arrIdx];
9269 bitStringToInt(&connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlInformation.tnlAddress, &ipAddress);
9270 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9272 /* If the TNL information is found in the data base, update the
9273 * information in the database */
9274 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9276 duCb.e2apDb.tnlAssoc[idx].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9282 /* If the TNL information is found in the data base, then add the
9283 * information in setupE2Connection array else add in failedToSetupE2Connection array */
9284 if(infoFound == true)
9286 count =connectionInfoList->numOfE2ConnectionSetup;
9287 connectionInfoList->setupE2Connection[count].ipV4Addr = duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr;
9288 connectionInfoList->setupE2Connection[count].usage = duCb.e2apDb.tnlAssoc[idx].usage;
9289 connectionInfoList->numOfE2ConnectionSetup++;
9293 count = connectionInfoList->numOfE2ConnectionFailedToSetup;
9294 connectionInfoList->failedToSetupE2Connection[count].ipV4Addr = ipAddress;
9295 connectionInfoList->failedToSetupE2Connection[count].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9296 connectionInfoList->numOfE2ConnectionFailedToSetup++;
9303 /*******************************************************************
9305 * @brief Handling of E2 connection removal Ie
9309 * Function : handleE2ConnectionRemoval
9311 * Functionality: Handling of E2 connection removal Ie
9314 * E2 Connection removal List
9317 ******************************************************************/
9319 void handleE2ConnectionRemoval(E2connectionUpdateRemove_List_t *connectionRemovalList)
9321 uint32_t ipAddress=0;
9322 uint8_t arrIdx=0,idx=0;
9323 E2connectionUpdateRemove_ItemIEs_t *connectionRemovalItem=NULLP;
9325 if(connectionRemovalList->list.array)
9327 for(arrIdx = 0; arrIdx < connectionRemovalList->list.count; arrIdx++)
9329 connectionRemovalItem= (E2connectionUpdateRemove_ItemIEs_t*)connectionRemovalList->list.array[arrIdx];
9330 bitStringToInt(&connectionRemovalItem->value.choice.E2connectionUpdateRemove_Item.tnlInformation.tnlAddress, &ipAddress);
9331 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9333 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9335 cmInetClose(&ricParams.sockFd);
9336 removeE2NodeInformation();
9345 /*******************************************************************
9347 * @brief Process e2 connection update received from RIC
9351 * Function : procE2ConnectionUpdate
9353 * Functionality: Process e2 connection update received from RIC
9355 * @param E2AP_PDU_t *e2apMsg
9358 ******************************************************************/
9360 void procE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
9362 uint8_t arrIdx =0, transId =0;
9363 bool invalidTransId = false, connectionFailedToUpdate=false;
9364 E2FailureCause failureCause;
9365 E2ConnectionList connectionInfoList;
9366 E2connectionUpdate_t *connectionUpdate=NULLP;
9368 DU_LOG("\nINFO --> E2AP : E2 connection update received");
9369 connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
9371 memset(&connectionInfoList, 0, sizeof(E2ConnectionList));
9372 for(arrIdx=0; arrIdx<connectionUpdate->protocolIEs.list.count; arrIdx++)
9374 switch(connectionUpdate->protocolIEs.list.array[arrIdx]->id)
9376 case ProtocolIE_IDE2_id_TransactionID:
9378 transId = connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
9381 failureCause.causeType = E2_PROTOCOL;
9382 failureCause.cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
9383 invalidTransId = true;
9388 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9390 handleE2ConnectionModification(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdate_List,\
9391 &connectionInfoList);
9392 if((connectionInfoList.numOfE2ConnectionSetup == 0) && (connectionInfoList.numOfE2ConnectionFailedToSetup > 0))
9394 failureCause.causeType = E2_TRANSPORT;
9395 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
9396 connectionFailedToUpdate =true;
9402 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9404 handleE2ConnectionRemoval(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdateRemove_List);
9410 DU_LOG("\nERROR --> E2AP : Invalid IE received[%ld]",connectionUpdate->protocolIEs.list.array[arrIdx]->id);
9415 if(invalidTransId == true || connectionFailedToUpdate ==true)
9419 if(invalidTransId == true || connectionFailedToUpdate == true)
9421 if(BuildAndSendE2ConnectionUpdateFailure(transId, failureCause) != ROK)
9423 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update failure");
9428 if(BuildAndSendE2ConnectionUpdateAcknowledge(transId, connectionInfoList) != ROK)
9430 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update ack");
9434 freeAperDecodingOfE2ConnectionUpdate(connectionUpdate);
9437 /*******************************************************************
9439 * @brief Free RIC Subscription action to be added list
9443 * Function : freeAperDecodingOfRicSubsActionToBeAdded
9445 * Functionality: Free the RIC Subscription action to be added list
9447 * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
9450 * ****************************************************************/
9451 void freeAperDecodingOfRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
9453 uint8_t elementIdx = 0;
9454 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
9456 if(subsDetails->list.array)
9458 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9460 if(subsDetails->list.array[elementIdx])
9462 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
9463 free(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf);
9464 free(subsDetails->list.array[elementIdx]);
9467 free(subsDetails->list.array);
9471 /*******************************************************************
9473 * @brief Deallocation of memory allocated by aper decoder for
9474 * RIC Subscription action to be removed list
9478 * Function : freeAperDecodingOfRicSubsActionToBeRemoved
9480 * Functionality: Free the RIC Subscription action to be removed list
9482 * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
9485 * ****************************************************************/
9486 void freeAperDecodingOfRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
9488 uint8_t elementIdx = 0;
9490 if(subsDetails->list.array)
9492 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9494 if(subsDetails->list.array[elementIdx])
9496 free(subsDetails->list.array[elementIdx]);
9499 free(subsDetails->list.array);
9503 /*******************************************************************
9505 * @brief Deallocation of memory allocated by aper decoder for
9506 * RIC Subscription action to be modify
9510 * Function : freeAperDecodingOfRicSubsActionToBeModified
9512 * Functionality: Free the RIC Subscription action to be modify
9514 * @params[in] RICactions_ToBeModifiedForModification_List_t List
9517 * ****************************************************************/
9518 void freeAperDecodingOfRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
9520 uint8_t elementIdx = 0;
9521 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
9523 if(subsDetails->list.array)
9525 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9527 if(subsDetails->list.array[elementIdx])
9529 actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx];
9530 if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
9532 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf);
9533 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition);
9535 free(subsDetails->list.array[elementIdx]);
9538 free(subsDetails->list.array);
9542 /*******************************************************************
9544 * @brief Deallocation of memory allocated by aper decoder for
9545 * RIC Subscription modification Request
9549 * Function freeAperDecodingOfRicSubsModificationReq
9551 * Functionality : Free RIC Subscription modification Request
9553 * @params[in] E2AP_PDU
9556 ******************************************************************/
9557 void freeAperDecodingOfRicSubsModificationReq(E2AP_PDU_t *e2apRicMsg)
9560 RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
9561 RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe;
9563 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
9565 if(ricSubscriptionModReq->protocolIEs.list.array)
9567 for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
9569 if(ricSubscriptionModReq->protocolIEs.list.array[idx])
9571 ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
9573 switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
9575 case ProtocolIE_IDE2_id_RICrequestID:
9578 case ProtocolIE_IDE2_id_RANfunctionID:
9581 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
9583 freeAperDecodingOfRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
9586 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
9588 freeAperDecodingOfRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
9591 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
9593 freeAperDecodingOfRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
9598 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
9604 free(ricSubscriptionModReq->protocolIEs.list.array[idx]);
9607 free(ricSubscriptionModReq->protocolIEs.list.array);
9611 /*******************************************************************
9613 * @brief Process RIC Subscription modification request
9617 * Function : procRicSubscriptionModificationRequest
9619 * Functionality: Process RIC subscription modification request.
9621 * @params[in] E2AP PDU
9624 ******************************************************************/
9625 void procRicSubscriptionModificationRequest(E2AP_PDU_t *e2apMsg)
9628 uint16_t ranFuncId = 0;
9629 bool procFailure = false;
9630 RicRequestId ricReqId;
9631 RanFunction *ranFuncDb = NULLP;
9632 CmLList *ricSubsNode = NULLP;
9633 RicSubscription *ricSubsDb = NULLP;
9634 RICsubscriptionModificationRequest_t *ricSubsModifyReq = NULLP;
9635 RICsubscriptionModificationRequest_IEs_t *ricSubsModifyReqIe = NULLP;
9637 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Request", __func__);
9642 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
9646 if(!e2apMsg->choice.initiatingMessage)
9648 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
9652 ricSubsModifyReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
9653 for(ieIdx = 0; ieIdx < ricSubsModifyReq->protocolIEs.list.count; ieIdx++)
9655 if(!ricSubsModifyReq->protocolIEs.list.array[ieIdx])
9657 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
9661 ricSubsModifyReqIe = ricSubsModifyReq->protocolIEs.list.array[ieIdx];
9662 switch(ricSubsModifyReqIe->id)
9664 case ProtocolIE_IDE2_id_RICrequestID:
9666 memset(&ricReqId, 0, sizeof(RicRequestId));
9667 ricReqId.requestorId = ricSubsModifyReqIe->value.choice.RICrequestID.ricRequestorID;
9668 ricReqId.instanceId = ricSubsModifyReqIe->value.choice.RICrequestID.ricInstanceID;
9672 case ProtocolIE_IDE2_id_RANfunctionID:
9674 ranFuncId = ricSubsModifyReqIe->value.choice.RANfunctionID;
9675 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
9678 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
9683 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
9686 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
9687 __func__, ricReqId.requestorId, ricReqId.instanceId);
9697 } /* End of switch for Protocol IE Id */
9701 } /* End of for loop for Protocol IE list */
9706 freeAperDecodingOfRicSubsModificationReq(e2apMsg);
9709 /*******************************************************************
9711 * @brief Handles received E2AP message and sends back response
9715 * Function : E2APMsgHdlr
9718 * - Decodes received E2AP control message
9719 * - Prepares response message, encodes and sends to SCTP
9722 * @return ROK - success
9725 * ****************************************************************/
9726 void E2APMsgHdlr(Buffer *mBuf)
9729 char *recvBuf = NULLP;
9731 MsgLen recvBufLen =0;
9732 E2AP_PDU_t *e2apMsg = NULLP;
9733 asn_dec_rval_t rval ={0}; /* Decoder return value */
9734 E2AP_PDU_t e2apasnmsg={0} ;
9736 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
9737 ODU_PRINT_MSG(mBuf, 0,0);
9739 /* Copy mBuf into char array to decode it */
9740 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
9741 DU_ALLOC(recvBuf, (Size)recvBufLen);
9743 if(recvBuf == NULLP)
9745 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
9748 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
9750 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
9754 #ifdef DEBUG_ASN_PRINT
9755 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
9756 for(i=0; i< recvBufLen; i++)
9758 printf("%x",recvBuf[i]);
9762 /* Decoding flat buffer into E2AP messsage */
9763 e2apMsg = &e2apasnmsg;
9764 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
9766 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
9767 DU_FREE(recvBuf, (Size)recvBufLen);
9769 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9771 DU_LOG("\nERROR --> E2AP : ASN decode failed");
9775 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
9777 switch(e2apMsg->present)
9779 case E2AP_PDU_PR_unsuccessfulOutcome:
9781 switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
9783 case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
9785 procE2SetupFailure(e2apMsg);
9788 case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure:
9790 procE2NodeConfigUpdateFailure(e2apMsg);
9793 case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure:
9795 procRicServiceUpdateFailure(e2apMsg);
9798 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse:
9800 procRicSubscriptionModificationRefuse(e2apMsg);
9803 case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
9805 ProcE2RemovalFailure(e2apMsg);
9810 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
9811 e2apMsg->choice.unsuccessfulOutcome->value.present);
9815 free(e2apMsg->choice.unsuccessfulOutcome);
9818 case E2AP_PDU_PR_successfulOutcome:
9820 switch(e2apMsg->choice.successfulOutcome->value.present)
9822 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
9826 procE2SetupRsp(e2apMsg);
9830 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
9832 procResetResponse(e2apMsg);
9835 case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge:
9837 procRicServiceUpdateAck(e2apMsg);
9840 case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm:
9842 procRicSubscriptionModificationConfirm(e2apMsg);
9845 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
9847 procE2NodeConfigUpdateAck(e2apMsg);
9850 case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
9852 ProcE2RemovalResponse(e2apMsg);
9857 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
9858 e2apMsg->choice.successfulOutcome->value.present);
9861 }/* End of switch(successfulOutcome) */
9862 free(e2apMsg->choice.successfulOutcome);
9866 case E2AP_PDU_PR_initiatingMessage:
9868 switch(e2apMsg->choice.initiatingMessage->value.present)
9870 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
9872 procRicSubscriptionRequest(e2apMsg);
9875 case InitiatingMessageE2__value_PR_RICserviceQuery:
9877 procRicServiceQuery(e2apMsg);
9880 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
9882 DU_LOG("\nINFO --> E2AP : Error indication received");
9885 case InitiatingMessageE2__value_PR_ResetRequestE2:
9887 DU_LOG("\nINFO --> E2AP : Reset request received");
9888 procE2ResetRequest(e2apMsg);
9891 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest:
9893 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Request received");
9894 procRicSubscriptionDeleteRequest(e2apMsg);
9897 case InitiatingMessageE2__value_PR_E2RemovalRequest:
9899 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
9900 procE2RemovalRequest(e2apMsg);
9903 case InitiatingMessageE2__value_PR_E2connectionUpdate:
9905 DU_LOG("\nINFO --> E2AP : E2 coneection update received");
9906 procE2ConnectionUpdate(e2apMsg);
9909 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest:
9911 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Request received");
9912 procRicSubscriptionModificationRequest(e2apMsg);
9917 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
9918 e2apMsg->choice.initiatingMessage->value.present);
9921 }/* End of switch(initiatingMessage) */
9922 free(e2apMsg->choice.initiatingMessage);
9927 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
9932 }/* End of switch(e2apMsg->present) */
9934 } /* End of E2APMsgHdlr */
9936 /**********************************************************************
9938 **********************************************************************/