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 add RIC Subs action info
3253 * Function : addRicSubsAction
3255 * Functionality: add Ric Subs action info
3259 * Pointer to Ric Subc info
3260 * Action Sequence list
3263 * @return ROK - success
3266 ******************************************************************/
3268 CmLList *addRicSubsAction(RanFunction *ranFuncDb, PTR ricSubsInfo, CmLListCp *actionSequence, uint8_t procedureCode, E2FailureCause *failureCause)
3270 CmLList *actionNode = NULLP;
3271 ActionInfo *actionDb = NULLP;
3272 RICactionID_t ricActionID;
3273 RICactionType_t ricActionType;
3274 RICactionDefinition_t *ricActionDefinition= NULLP;
3275 RICaction_ToBeSetup_Item_t *setupItem= NULLP;
3276 RICaction_ToBeAddedForModification_Item_t *addIem= NULLP;
3277 RICaction_ToBeModifiedForModification_Item_t *modifiedItem= NULLP;
3278 RICaction_ToBeRemovedForModification_Item_t *removedItem= NULLP;
3280 switch(procedureCode)
3282 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
3284 setupItem = (RICaction_ToBeSetup_Item_t *)ricSubsInfo;
3285 ricActionID= setupItem->ricActionID;
3286 ricActionType= setupItem->ricActionType;
3287 if(setupItem->ricActionDefinition)
3289 ricActionDefinition = setupItem->ricActionDefinition;
3293 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
3295 addIem = (RICaction_ToBeAddedForModification_Item_t*) ricSubsInfo;
3296 ricActionID= addIem->ricActionID;
3297 ricActionType= addIem->ricActionType;
3298 ricActionDefinition = &addIem->ricActionDefinition;
3302 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
3304 modifiedItem= (RICaction_ToBeModifiedForModification_Item_t*)ricSubsInfo;
3305 ricActionID= modifiedItem->ricActionID;
3306 if(modifiedItem->ricActionDefinition)
3308 ricActionDefinition = modifiedItem->ricActionDefinition;
3312 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
3314 removedItem= (RICaction_ToBeRemovedForModification_Item_t*)ricSubsInfo;
3315 ricActionID= removedItem->ricActionID;
3321 DU_ALLOC(actionDb, sizeof(ActionInfo));
3324 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
3327 if(ricActionType== RICactionType_report)
3329 actionDb->actionId = ricActionID;
3330 actionDb->type = REPORT;
3332 if(extractRicActionDef(ranFuncDb, &actionDb->definition, ricActionDefinition, failureCause) == ROK)
3334 actionDb->action = CONFIG_ADD;
3337 DU_ALLOC(actionNode, sizeof(CmLList));
3340 actionNode->node = (PTR) actionDb;
3341 cmLListAdd2Tail(actionSequence, actionNode);
3345 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
3346 DU_FREE(actionDb, sizeof(ActionInfo));
3353 /*******************************************************************
3355 * @brief Extract RIC Action to be setup
3359 * Function : extractRicActionToBeSetup
3361 * Functionality : This function :
3362 * - Validates that each action-to-be-setup is supported by E2 node
3363 * - Stores event trigger details in local DB
3365 * @params[in] RAN Function Database structure
3366 * RIC Subscription Info to be added to RAN function
3367 * RIC Action To Be Setup List received from RIC
3368 * @return ROK - success
3371 ******************************************************************/
3372 uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
3373 RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause, PendingSubsRspInfo *subsRsp)
3375 CmLList *actionNode = NULLP;
3376 uint8_t actionIdx = 0;
3377 uint8_t ricActionId = 0;
3378 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
3380 if(actionList->list.array)
3382 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
3384 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)actionList->list.array[actionIdx];
3385 switch(actionItem->id)
3387 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
3389 /* If Action type is REPORT and
3390 * If RIC action definition's extraction and validation passes,
3392 * This action is added to action sequence list of subscription info */
3393 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeSetup_Item,\
3394 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item, failureCause);
3398 /* In case of any failure, action is rejected
3399 * Added to rejected-action-list in subscription response */
3400 subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId;
3401 if(failureCause->causeType == E2_NOTHING)
3403 failureCause->causeType = E2_RIC_REQUEST;
3404 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3406 memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \
3407 failureCause, sizeof(E2FailureCause));
3408 subsRsp->numOfRejectedActions++;
3413 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
3419 /* If there is even 1 action that can be added, return ROK */
3420 if(ricSubscriptionInfo->actionSequence.count)
3423 if(failureCause->causeType == E2_NOTHING)
3425 failureCause->causeType = E2_RIC_REQUEST;
3426 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3431 /******************************************************************
3433 * @brief Processes RIC Subscription Req sent by RIC
3437 * Function : procRicSubscriptionRequest
3439 * Functionality: Processes RIC Subscription Request from RIC
3441 * @params[in] E2AP_PDU_t ASN decoded E2AP message
3442 * @return ROK - success
3445 * ****************************************************************/
3446 uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg)
3450 uint16_t ranFuncId = 0;
3451 RicRequestId ricReqId;
3452 CmLList *ricSubscriptionNode = NULLP;
3453 RanFunction *ranFuncDb = NULLP;
3454 RICsubscriptionRequest_t *ricSubsReq = NULLP;
3455 RICsubscriptionDetails_t *subsDetails = NULLP;
3456 RicSubscription *ricSubscriptionInfo = NULLP;
3457 E2FailureCause failureCause;
3459 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
3461 memset(&failureCause, 0, sizeof(E2FailureCause));
3462 memset(&ricReqId, 0, sizeof(RicRequestId));
3464 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
3465 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
3467 if(ricSubsReq->protocolIEs.list.array[idx])
3469 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
3471 case ProtocolIE_IDE2_id_RICrequestID:
3473 ricReqId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID;
3474 ricReqId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID;
3479 case ProtocolIE_IDE2_id_RANfunctionID:
3481 ranFuncId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID;
3483 /* Validating RAN Function id */
3484 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
3488 failureCause.causeType = E2_RIC_REQUEST;
3489 failureCause.cause = E2_RAN_FUNCTION_ID_INVALID;
3494 if(ranFuncDb->numPendingSubsRsp >= MAX_PENDING_SUBSCRIPTION_RSP)
3496 failureCause.causeType = E2_RIC_REQUEST;
3497 failureCause.cause = E2_FUNCTION_RESOURCE_LIMIT;
3502 DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription));
3503 if(!ricSubscriptionInfo)
3505 DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
3506 failureCause.causeType = E2_MISCELLANEOUS;
3507 failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3511 ricSubscriptionInfo->requestId.requestorId = ricReqId.requestorId;
3512 ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId;
3513 ricSubscriptionInfo->ranFuncId = ranFuncId;
3515 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3516 memcpy(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].requestId,
3517 &ricReqId, sizeof(RicRequestId));
3518 ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].ranFuncId = ranFuncId;
3522 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
3524 subsDetails = &ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails;
3526 /* Decode, Validate and record Event Trigger Definition */
3527 if(extractEventTriggerDef(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricEventTriggerDefinition, \
3528 &failureCause) != ROK)
3534 /* Decode, Validate and record RIC actions */
3535 if(extractRicActionToBeSetup(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricAction_ToBeSetup_List, \
3536 &failureCause, &ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp]) != ROK)
3545 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
3546 ricSubsReq->protocolIEs.list.array[idx]->id);
3555 freeAperDecodingOfRicSubsReq(ricSubsReq);
3559 cmInitTimers(&(ricSubscriptionInfo->ricSubsReportTimer), 1);
3560 ricSubscriptionInfo->action = CONFIG_ADD;
3562 /* Add RAN subcription detail to RAN function */
3563 DU_ALLOC(ricSubscriptionNode, sizeof(CmLList));
3564 if(ricSubscriptionNode)
3566 ricSubscriptionNode->node = (PTR) ricSubscriptionInfo;
3567 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubscriptionNode);
3570 ranFuncDb->numPendingSubsRsp++;
3572 #ifdef KPI_CALCULATION
3573 /* Send statistics request to other DU entities */
3574 BuildAndSendStatsReq(ricSubscriptionInfo);
3579 DU_FREE(ricSubscriptionInfo, sizeof(RicSubscription));
3583 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3586 /* Send RIC Subcription Failure */
3587 BuildAndSendRicSubscriptionFailure(ricReqId, ranFuncId, failureCause);
3592 /******************************************************************
3594 * @brief Free RIC Subscription Failure
3598 * Function : FreeRicSubscriptionFailure
3600 * Functionality: Free RIC Subscription Failure
3602 * @params[in] E2AP PDU
3605 * ****************************************************************/
3606 void FreeRicSubscriptionFailure(E2AP_PDU_t *e2apMsg)
3608 uint8_t elemIdx = 0;
3609 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3613 if(e2apMsg->choice.unsuccessfulOutcome)
3615 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3616 if(ricSubscriptionFailure->protocolIEs.list.array)
3618 for(elemIdx = 0; elemIdx < ricSubscriptionFailure->protocolIEs.list.count; elemIdx++)
3620 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3622 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3624 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3626 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3630 /******************************************************************
3632 * @brief Fill and Send RIC Subscription Failure to RIC
3636 * Function : BuildAndSendRicSubscriptionFailure
3638 * Functionality: Fill and Send RIC Subscription Failure to RIC
3640 * @params[in] RIC Request ID
3643 * @return ROK - success
3646 * ****************************************************************/
3647 uint8_t BuildAndSendRicSubscriptionFailure(RicRequestId ricReqId, uint16_t ranFuncId, E2FailureCause failureCause)
3649 uint8_t ret = RFAILED;
3650 uint8_t elementCnt = 0, elemIdx = 0;
3651 E2AP_PDU_t *e2apMsg = NULLP;
3652 asn_enc_rval_t encRetVal; /* Encoder return value */
3653 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3654 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3658 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Failure\n");
3660 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3661 if(e2apMsg == NULLP)
3663 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3667 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3668 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3669 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3671 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3674 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
3675 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3676 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure;
3678 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3681 ricSubscriptionFailure->protocolIEs.list.count = elementCnt;
3682 ricSubscriptionFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionFailure_IEs_t *);
3683 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3684 if(!ricSubscriptionFailure->protocolIEs.list.array)
3686 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3690 for(elemIdx = 0; elemIdx < elementCnt; elemIdx++)
3692 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3693 if(!ricSubscriptionFailure->protocolIEs.list.array[elemIdx])
3695 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d] for IE at index [%d]", \
3696 __func__, __LINE__, elemIdx);
3700 if(elemIdx < elementCnt)
3705 /* RIC Request ID */
3706 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3707 ricSubsFailIe->id = ProtocolIE_IDE2_id_RICrequestID;
3708 ricSubsFailIe->criticality = CriticalityE2_reject;
3709 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
3710 ricSubsFailIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3711 ricSubsFailIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3713 /* RAN Function ID */
3714 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3715 ricSubsFailIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3716 ricSubsFailIe->criticality = CriticalityE2_reject;
3717 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
3718 ricSubsFailIe->value.choice.RANfunctionID = ranFuncId;
3721 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3722 ricSubsFailIe->id = ProtocolIE_IDE2_id_CauseE2;
3723 ricSubsFailIe->criticality = CriticalityE2_reject;
3724 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_CauseE2;
3725 fillE2Cause(&ricSubsFailIe->value.choice.CauseE2, failureCause);
3727 /* Prints the Msg formed */
3728 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3729 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3731 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3732 if(encRetVal.encoded == ENCODE_FAIL)
3734 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Failure Message (at %s)\n",\
3735 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3740 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Failure Message \n");
3741 #ifdef DEBUG_ASN_PRINT
3742 for(int i=0; i< encBufSize; i++)
3744 printf("%x",encBuf[i]);
3749 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
3751 DU_LOG("\nINFO --> E2AP : Sending RIC Subscription Failure");
3757 FreeRicSubscriptionFailure(e2apMsg);
3761 /*******************************************************************
3763 * @brief Free the RicIndication Message
3767 * Function : FreeRicIndication
3769 * Functionality: Free the RicIndication Message
3774 ******************************************************************/
3775 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
3778 RICindication_t *ricIndicationMsg= NULLP;
3780 if(e2apMsg != NULLP)
3782 if(e2apMsg->choice.initiatingMessage != NULLP)
3784 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
3785 if(ricIndicationMsg!= NULLP)
3787 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
3789 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
3791 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
3793 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
3795 case ProtocolIE_IDE2_id_RICrequestID:
3796 case ProtocolIE_IDE2_id_RANfunctionID:
3797 case ProtocolIE_IDE2_id_RICactionID:
3798 case ProtocolIE_IDE2_id_RICindicationType:
3801 case ProtocolIE_IDE2_id_RICindicationHeader:
3803 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
3804 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
3807 case ProtocolIE_IDE2_id_RICindicationMessage:
3809 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
3810 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
3816 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
3819 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
3822 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3824 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3828 /*******************************************************************
3830 * @brief Free measurement record
3834 * Function : freeMeasRecord
3836 * Functionality: Free all measurement recorded for a measurement
3837 * within an action in a RIC subscription
3839 * @param Measurement data to be freed
3842 ******************************************************************/
3843 void freeMeasData(MeasurementData_t *measData)
3845 uint8_t measIdx = 0, measRecIdx = 0;
3846 MeasurementRecord_t *measRecord = NULLP;
3848 if(measData->list.array)
3850 for(measIdx = 0; measIdx < measData->list.count; measIdx++)
3852 if(measData->list.array[measIdx])
3854 measRecord = &measData->list.array[measIdx]->measRecord;
3855 if(measRecord->list.array)
3857 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3859 DU_FREE(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3861 DU_FREE(measRecord->list.array, measRecord->list.size);
3863 DU_FREE(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
3866 DU_FREE(measData->list.array, measData->list.size);
3870 /*******************************************************************
3872 * @brief Fill measurement info list
3876 * Function : freeMeasInfoList
3878 * Functionality: Fills all measurement info within an action
3879 * in a RIC subscription
3881 * @param Measurement Info list to be freed
3884 ******************************************************************/
3885 void freeMeasInfoList(MeasurementInfoList_t *measInfoList)
3887 uint8_t measInfoIdx = 0;
3889 if(measInfoList->list.array)
3891 for(measInfoIdx = 0; measInfoIdx < measInfoList->list.count; measInfoIdx++)
3893 if(measInfoList->list.array[measInfoIdx])
3895 DU_FREE(measInfoList->list.array[measInfoIdx]->measType.choice.measName.buf, \
3896 measInfoList->list.array[measInfoIdx]->measType.choice.measName.size);
3898 DU_FREE(measInfoList->list.array[measInfoIdx], measInfoList->list.size);
3901 DU_FREE(measInfoList->list.array, measInfoList->list.size);
3905 /*******************************************************************
3907 * @brief Free E2SM-KPM Indication Message
3911 * Function : FreeE2smKpmIndicationMessage
3913 * Functionality: Free E2SM-KPM Indication Message
3915 * @param E2SM-KPM Indication message to be freed
3918 ******************************************************************/
3919 void FreeE2smKpmIndicationMessage(E2SM_KPM_IndicationMessage_t *e2smKpmIndMsg)
3921 E2SM_KPM_IndicationMessage_Format1_t *format1Msg = NULLP;
3923 switch(e2smKpmIndMsg->indicationMessage_formats.present)
3925 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
3927 if(e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1)
3929 format1Msg = e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1;
3931 /* Measurement Data */
3932 freeMeasData(&format1Msg->measData);
3934 /* Measurement Info List */
3935 if(format1Msg->measInfoList)
3937 freeMeasInfoList(format1Msg->measInfoList);
3938 DU_FREE(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
3941 /* Granularity Period */
3942 DU_FREE(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
3944 DU_FREE(format1Msg, sizeof(E2SM_KPM_IndicationMessage_Format1_t));
3949 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
3950 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
3956 /*******************************************************************
3958 * @brief Fill measurement record
3962 * Function : fillMeasRecord
3964 * Functionality: Fills all measurement value for a measurement
3965 * within an action in a RIC subscription
3967 * @param Measurement record to be filled
3968 * Measurement database with measurement records
3969 * @return ROK - success
3972 ******************************************************************/
3973 uint8_t fillMeasRecord(MeasurementRecord_t *measRecord, MeasurementInfo *measInfoDb)
3975 uint8_t measRecIdx = 0;
3976 CmLList *measValNode = NULLP;
3979 measRecord->list.count = measInfoDb->measuredValue.count;
3980 measRecord->list.size = measRecord->list.count * sizeof(MeasurementRecordItem_t *);
3982 DU_ALLOC(measRecord->list.array, measRecord->list.size);
3983 if(!measRecord->list.array)
3985 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3989 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3991 DU_ALLOC(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3992 if(!measRecord->list.array[measRecIdx])
3994 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4000 CM_LLIST_FIRST_NODE(&measInfoDb->measuredValue, measValNode);
4003 measVal = *(double *)measValNode->node;
4004 if(measVal == (int)measVal)
4006 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_integer;
4007 measRecord->list.array[measRecIdx]->choice.integer = (int)measVal;
4011 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_real;
4012 measRecord->list.array[measRecIdx]->choice.real = measVal;
4015 measValNode= measValNode->next;
4016 /* Once the measurement record is added to the message, delete it from DB */
4019 deleteMeasuredValueList(&measInfoDb->measuredValue);
4023 /*******************************************************************
4025 * @brief Fills measuerement data
4029 * Function : fillMeasData
4031 * Functionality: Fill all measurement recorded for all measurements
4032 * in an action in a RIC subscription
4034 * @param Measurement data to be filled
4035 * Measurement info list from an action DB
4036 * @return ROK - success
4039 ******************************************************************/
4040 uint8_t fillMeasData(MeasurementData_t *measData, CmLListCp *measInfoListDb)
4042 uint8_t measIdx = 0;
4043 CmLList *measInfoNode = NULLP;
4044 MeasurementInfo *measInfoDb = NULLP;
4045 MeasurementRecord_t *measRecord = NULLP;
4047 measData->list.count = measInfoListDb->count;
4048 measData->list.size = measData->list.count * sizeof(MeasurementDataItem_t *);
4050 DU_ALLOC(measData->list.array, measData->list.size);
4051 if(!measData->list.array)
4053 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4058 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4061 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4064 DU_ALLOC(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
4065 if(!measData->list.array[measIdx])
4067 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4071 measRecord = &measData->list.array[measIdx]->measRecord;
4072 if(fillMeasRecord(measRecord, measInfoDb) != ROK)
4074 DU_LOG("\nERROR --> E2AP : Failed to fill measurement record");
4079 measInfoNode = measInfoNode->next;
4085 /*******************************************************************
4087 * @brief Fill all measurement info
4091 * Function : fillMeasInfoList
4093 * Functionality: Fills all measurement info belonging to an action
4094 * in a RIC subscription
4096 * @param Measurement Info list to be filled
4097 * Measurement Info list from E2AP DB
4098 * @return ROK - success
4101 ******************************************************************/
4102 uint8_t fillMeasInfoList(MeasurementInfoList_t *measInfoList, CmLListCp *measInfoListDb)
4104 uint8_t measInfoIdx = 0;
4105 CmLList *measInfoNode = NULLP;
4106 MeasurementInfo *measInfoDb = NULLP;
4107 MeasurementInfoItem_t *measInfoItem = NULLP;
4109 measInfoList->list.count = measInfoListDb->count;
4110 measInfoList->list.size = measInfoList->list.count * sizeof(MeasurementInfoItem_t *);
4112 DU_ALLOC(measInfoList->list.array, measInfoList->list.size);
4113 if(!measInfoList->list.array)
4115 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4120 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4123 DU_ALLOC(measInfoList->list.array[measInfoIdx], sizeof(MeasurementInfoItem_t));
4124 if(!measInfoList->list.array[measInfoIdx])
4126 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4130 measInfoItem = measInfoList->list.array[measInfoIdx];
4131 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4134 /* Measurement Type */
4135 measInfoItem->measType.present = MeasurementType_PR_measName;
4136 measInfoItem->measType.choice.measName.size = strlen(measInfoDb->measurementTypeName);
4138 DU_ALLOC(measInfoItem->measType.choice.measName.buf, measInfoItem->measType.choice.measName.size);
4139 if(!measInfoItem->measType.choice.measName.buf)
4141 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4145 memcpy(measInfoItem->measType.choice.measName.buf, measInfoDb->measurementTypeName,\
4146 measInfoItem->measType.choice.measName.size);
4150 measInfoNode = measInfoNode->next;
4157 /*******************************************************************
4159 * @brief Fill E2SM-KPM Indication Message Format 1
4163 * Function : fillE2smKpmIndMsgFormat1
4165 * Functionality: Fill E2SM-KPM Indication Message Format 1
4167 * @param Format 1 Message to be filled
4168 * Action Definition format 1 from E2AP DB
4169 * @return ROK - success
4172 ******************************************************************/
4173 uint8_t fillE2smKpmIndMsgFormat1(E2SM_KPM_IndicationMessage_Format1_t *format1Msg, ActionDefFormat1 *format1)
4175 /* Measurement Data */
4176 if(fillMeasData(&format1Msg->measData, &format1->measurementInfoList) != ROK)
4178 DU_LOG("\nERROR --> E2AP : Failed to fill measurement data");
4182 /* Measurement Information */
4183 DU_ALLOC(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
4184 if(!format1Msg->measInfoList)
4186 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4190 if(fillMeasInfoList(format1Msg->measInfoList, &format1->measurementInfoList) != ROK)
4192 DU_LOG("\nERROR --> E2AP : Failed to fill measurement information list");
4196 /* Granularity Period */
4197 DU_ALLOC(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
4198 if(!format1Msg->granulPeriod)
4200 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4203 *(format1Msg->granulPeriod) = format1->granularityPeriod;
4208 /*******************************************************************
4210 * @brief Fill RIC Indication Message buffer
4214 * Function : fillRicIndMsgBuf
4216 * Functionality: Fill E2SM-KPM Indication Message
4217 * Encode this message and copy to RIC Indication Message buffer
4219 * @param RIC Indication Message buffer to be filled
4220 * Source action info from E2AP DB
4221 * @return ROK - success
4224 ******************************************************************/
4225 uint8_t fillRicIndMsgBuf(RICindicationMessage_t *ricIndMsgBuf, ActionInfo *actionInfo)
4227 uint8_t ret = RFAILED;
4228 bool failedInFormat = false;
4229 E2SM_KPM_IndicationMessage_t e2smKpmIndMsg;
4230 asn_enc_rval_t encRetVal; /* Encoder return value */
4232 memset(&e2smKpmIndMsg, 0, sizeof(E2SM_KPM_IndicationMessage_t));
4236 /* E2SM-KPM Indication message format type */
4237 e2smKpmIndMsg.indicationMessage_formats.present = actionInfo->definition.formatType;
4238 switch(e2smKpmIndMsg.indicationMessage_formats.present)
4240 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
4242 /* E2SM-KPM Indication message format 1 */
4243 DU_ALLOC(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4244 sizeof(E2SM_KPM_IndicationMessage_Format1_t));
4245 if(!e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1)
4247 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4248 failedInFormat = true;
4252 if(fillE2smKpmIndMsgFormat1(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4253 &actionInfo->definition.choice.format1) != ROK)
4255 DU_LOG("\nERROR --> E2AP : Failed to fill E2SM-KPM Indication message format 1");
4256 failedInFormat = true;
4262 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
4263 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
4266 DU_LOG("\nERROR --> E2AP : fillRicIndMsgBuf: Only Format 1 supported");
4267 failedInFormat = true;
4275 /* Encode E2SM-KPM Indication Message */
4276 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationMessage, &e2smKpmIndMsg);
4277 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4279 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationMessage, 0, &e2smKpmIndMsg, PrepFinalEncBuf, encBuf);
4280 if(encRetVal.encoded == ENCODE_FAIL)
4282 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Message (at %s)\n",\
4283 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4288 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Message \n");
4289 #ifdef DEBUG_ASN_PRINT
4290 for(int i=0; i< encBufSize; i++)
4292 printf("%x",encBuf[i]);
4297 /* Copy encoded string to RIC Indication Message buffer */
4298 ricIndMsgBuf->size = encBufSize;
4299 DU_ALLOC(ricIndMsgBuf->buf, ricIndMsgBuf->size);
4300 if(!ricIndMsgBuf->buf)
4302 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4305 memset(ricIndMsgBuf->buf, 0, ricIndMsgBuf->size);
4306 memcpy(ricIndMsgBuf->buf, encBuf, encBufSize);
4312 /* Free E2SM-KPM Indication Message */
4313 FreeE2smKpmIndicationMessage(&e2smKpmIndMsg);
4318 /*******************************************************************
4320 * @brief Free E2SM-KPM Indication Header
4324 * Function : FreeE2smKpmIndicationHeader
4326 * Functionality: Free E2SM-KPM Indication Header
4328 * @param E2SM-KPM Indication Header to be free
4331 ******************************************************************/
4332 void FreeE2smKpmIndicationHeader(E2SM_KPM_IndicationHeader_t *e2smKpmIndHdr)
4334 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4338 switch(e2smKpmIndHdr->indicationHeader_formats.present)
4340 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4342 if(e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1)
4344 format1 = e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1;
4346 DU_FREE(format1->colletStartTime.buf, format1->colletStartTime.size);
4347 DU_FREE(format1, sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4351 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4358 /*******************************************************************
4360 * @brief Fill RIC Indication Header buffer
4364 * Function : fillRicIndHeader
4366 * Functionality: Fill E2SM-KPM Indication Header
4367 * Encode this message and copy to RIC Indication Header buffer
4369 * @param RIC Indication Header buffer to be filled
4370 * Source RIC subscription info from E2AP DB
4371 * @return ROK - success
4374 ******************************************************************/
4375 uint8_t fillRicIndHeader(RICindicationHeader_t *ricIndHdr, RicSubscription *ricSubsInfo)
4377 uint8_t ret = RFAILED;
4378 uint8_t secBufIdx = 0, milliSecBufIdx = 0;
4380 bool formatFailure = false;
4381 RanFunction *ranFunc = NULLP;
4382 ReportStartTime *startTime = NULLP;
4383 E2SM_KPM_IndicationHeader_t e2smKpmIndHdr;
4384 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4385 asn_enc_rval_t encRetVal; /* Encoder return value */
4389 ranFunc = fetchRanFuncFromRanFuncId(ricSubsInfo->ranFuncId);
4390 if(ranFunc == NULLP)
4392 DU_LOG("\nERROR --> E2AP : RAN Function ID [%d] not found", ricSubsInfo->ranFuncId);
4396 memset(&e2smKpmIndHdr, 0, sizeof(E2SM_KPM_IndicationHeader_t));
4398 e2smKpmIndHdr.indicationHeader_formats.present = ranFunc->ricIndicationHeaderFormat;
4399 switch(e2smKpmIndHdr.indicationHeader_formats.present)
4401 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4403 DU_ALLOC(e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1, \
4404 sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4405 if(!e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1)
4407 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4408 formatFailure = true;
4411 format1 = e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1;
4413 /* Fetch reporting period start time from DB */
4414 switch(ricSubsInfo->eventTriggerDefinition.formatType)
4418 startTime = &ricSubsInfo->eventTriggerDefinition.choice.format1.startTime;
4422 format1->colletStartTime.size = 8 * sizeof(uint8_t);
4423 DU_ALLOC(format1->colletStartTime.buf, format1->colletStartTime.size);
4424 if(!format1->colletStartTime.buf)
4426 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4427 formatFailure = true;
4431 /* As per O-RAN.WG3.E2SM-KPM-R003-v03.00, section 8.3.12 and
4432 * RFC 5905, section 6 :
4433 * Time stamp has a 64-bit format where first 32-bit is seconds
4434 * and next 32-bit is fraction in picosecond-level.
4435 * This fraction has been rounded in microseconds.
4438 * Storing 32-bit seconds at MSB 0-3 and
4439 * 32-bit milliseconds at next 4 bytes i.e. bytes 4-7
4443 for(byteIdx = 3; byteIdx >= 0; byteIdx--)
4445 format1->colletStartTime.buf[secBufIdx++] = startTime->timeInSec >> (8*byteIdx);
4446 format1->colletStartTime.buf[milliSecBufIdx++] = startTime->timeInMilliSec >> (8*byteIdx);
4451 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4454 DU_LOG("\nERROR --> E2AP : Only E2SM-KPM Indication Header Format 1 supported");
4455 formatFailure = true;
4463 /* Encode E2SM-KPM Indication Header */
4464 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationHeader, &e2smKpmIndHdr);
4465 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4467 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationHeader, 0, &e2smKpmIndHdr, PrepFinalEncBuf, encBuf);
4468 if(encRetVal.encoded == ENCODE_FAIL)
4470 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Header (at %s)\n",\
4471 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4476 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Header \n");
4477 #ifdef DEBUG_ASN_PRINT
4478 for(int i=0; i< encBufSize; i++)
4480 printf("%x",encBuf[i]);
4485 /* Copy encoded string to RIC Indication Header buffer */
4486 ricIndHdr->size = encBufSize;
4487 DU_ALLOC(ricIndHdr->buf, ricIndHdr->size);
4490 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4493 memset(ricIndHdr->buf, 0, ricIndHdr->size);
4494 memcpy(ricIndHdr->buf, encBuf, encBufSize);
4499 /* Free E2SM-KPM Indication Header */
4500 FreeE2smKpmIndicationHeader(&e2smKpmIndHdr);
4505 /*******************************************************************
4507 * brief Fill the RIC Indication Message
4511 * Function : fillRicIndication
4513 * Functionality: Fills the RIC Indication Message
4515 * @param RIC Indication Message to be filled
4516 * RIC Subscription DB
4518 * @return ROK - success
4521 ******************************************************************/
4522 uint8_t fillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4524 uint8_t elementCnt = 0, idx = 0;
4529 ricIndicationMsg->protocolIEs.list.count = elementCnt;
4530 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_IEs_t *);
4532 /* Initialize the Ric Indication members */
4533 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, ricIndicationMsg->protocolIEs.list.size);
4534 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
4536 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4540 for(idx=0; idx<elementCnt; idx++)
4542 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx], sizeof(RICindication_IEs_t));
4543 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
4545 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4550 /* RIC Request ID */
4552 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
4553 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4554 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICrequestID;
4555 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = \
4556 ricSubscriptionInfo->requestId.requestorId;
4557 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = \
4558 ricSubscriptionInfo->requestId.instanceId;
4560 /* RAN Function ID */
4562 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
4563 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4564 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RANfunctionID;
4565 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ricSubscriptionInfo->ranFuncId;
4569 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
4570 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4571 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICactionID;
4572 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = actionInfo->actionId;
4574 /* RIC Indication Type */
4576 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
4577 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4578 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationType;
4579 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = actionInfo->type;
4581 /* RIC Indication Header */
4583 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
4584 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4585 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationHeader;
4586 if(fillRicIndHeader(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader, \
4587 ricSubscriptionInfo) != ROK)
4589 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication header");
4593 /* RIC Indication Message */
4595 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
4596 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4597 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationMessage;
4598 if(fillRicIndMsgBuf(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage, \
4601 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication Message");
4608 /*******************************************************************
4610 * @brief Builds and Send the RicIndication Message
4614 * Function : BuildAndSendRicIndication
4616 * Functionality:Fills the RicIndication Message
4618 * @return ROK - success
4621 ******************************************************************/
4623 uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4625 uint8_t ret = RFAILED;
4626 E2AP_PDU_t *e2apMsg = NULLP;
4627 RICindication_t *ricIndicationMsg = NULLP;
4628 asn_enc_rval_t encRetVal; /* Encoder return value */
4632 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
4634 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4635 if(e2apMsg == NULLP)
4637 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4641 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4642 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4643 if(e2apMsg->choice.initiatingMessage == NULLP)
4645 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4648 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
4649 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4650 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
4652 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
4654 if(fillRicIndication(ricIndicationMsg, ricSubscriptionInfo, actionInfo) != ROK)
4656 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication message");
4660 /* Prints the Msg formed */
4661 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4662 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4664 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4666 if(encRetVal.encoded == ENCODE_FAIL)
4668 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
4669 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4674 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
4675 #ifdef DEBUG_ASN_PRINT
4676 for(int i=0; i< encBufSize; i++)
4678 printf("%x",encBuf[i]);
4683 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
4685 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
4691 FreeRicIndication(e2apMsg);
4695 /*******************************************************************
4697 * @brief free e2 node component configuration req and rsp
4701 * Function : freeE2NodeComponentConfiguration
4704 * - free e2 node component configuration req and rsp
4706 * @params[in] E2nodeComponentConfiguration_t *e2nodeComponentConfiguration
4707 * @return ROK - success
4710 * ****************************************************************/
4712 void freeE2NodeComponentConfiguration(E2nodeComponentConfiguration_t *e2nodeComponentConfiguration)
4714 /* Free E2 Node Component Request Part */
4715 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentRequestPart.buf, e2nodeComponentConfiguration->e2nodeComponentRequestPart.size);
4717 /* Free E2 Node Component Response Part */
4718 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentResponsePart.buf, e2nodeComponentConfiguration->e2nodeComponentResponsePart.size);
4722 /*******************************************************************
4724 * @brief free e2 node component component identifier
4728 * Function : freeE2NodeComponentIdentifier
4731 * - free e2 node component component identifier
4733 * @params[in] E2nodeComponentID_t *componentID
4734 * @return ROK - success
4737 * ****************************************************************/
4739 void freeE2NodeComponentIdentifier(E2nodeComponentID_t *componentID)
4741 if(componentID->choice.e2nodeComponentInterfaceTypeF1)
4743 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
4744 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
4749 /*******************************************************************
4751 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
4755 * Function : FreeE2NodeConfigUpdate
4758 * - freeing the memory allocated for E2nodeConfigurationUpdate
4760 * @params[in] E2AP_PDU_t *e2apMsg
4761 * @return ROK - success
4764 * ****************************************************************/
4766 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
4768 uint8_t arrIdx =0, e2NodeUpdateListIdx=0, e2NodeRemovalListIdx=0, e2NodeAddListIdx=0;
4769 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate =NULL;
4770 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList =NULL;
4771 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItem =NULL;
4772 E2nodeComponentConfigRemoval_List_t *e2NodeRemovalList =NULL;
4773 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItem =NULL;
4774 E2nodeComponentConfigAddition_List_t *e2NodeAddList =NULL;
4775 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem =NULL;
4777 if(e2apMsg != NULLP)
4779 if(e2apMsg->choice.initiatingMessage != NULLP)
4781 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4782 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
4784 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
4786 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx])
4789 switch(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id)
4791 case ProtocolIE_IDE2_id_TransactionID:
4794 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
4796 e2NodeAddList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
4797 if(e2NodeAddList->list.array)
4799 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
4801 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
4803 freeE2NodeComponentConfiguration(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration);
4804 freeE2NodeComponentIdentifier(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID);
4805 DU_FREE(e2NodeAddItem, sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
4807 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
4811 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
4813 e2NodeUpdateList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List;
4814 if(e2NodeUpdateList->list.array)
4816 for(e2NodeUpdateListIdx = 0; e2NodeUpdateListIdx< e2NodeUpdateList->list.count; e2NodeUpdateListIdx++)
4818 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[e2NodeUpdateListIdx];
4820 freeE2NodeComponentConfiguration(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentConfiguration);
4821 freeE2NodeComponentIdentifier(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentID);
4822 DU_FREE(e2NodeUpdateItem, sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
4824 DU_FREE(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
4828 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
4830 e2NodeRemovalList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List;
4831 if(e2NodeRemovalList->list.array)
4833 for(e2NodeRemovalListIdx = 0; e2NodeRemovalListIdx< e2NodeRemovalList->list.count; e2NodeRemovalListIdx++)
4835 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemovalList->list.array[e2NodeRemovalListIdx];
4837 freeE2NodeComponentIdentifier(&e2NodeRemovalItem->value.choice.E2nodeComponentConfigRemoval_Item.e2nodeComponentID);
4838 DU_FREE(e2NodeRemovalItem, sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
4840 DU_FREE(e2NodeRemovalList->list.array, e2NodeRemovalList->list.size);
4848 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4851 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4853 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4855 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4859 /*******************************************************************
4861 * @brief Buld and send the E2 node config update msg
4865 * Function : BuildAndSendE2NodeConfigUpdate
4868 * - Buld and send the E2 node config update msg
4871 * @return ROK - success
4874 * ****************************************************************/
4876 uint8_t BuildAndSendE2NodeConfigUpdate(E2NodeConfigList *e2NodeList)
4878 uint8_t ret = RFAILED;
4879 uint8_t arrIdx = 0,elementCnt = 0, transId=0;
4880 E2AP_PDU_t *e2apMsg = NULLP;
4881 asn_enc_rval_t encRetVal; /* Encoder return value */
4882 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
4884 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
4887 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4888 if(e2apMsg == NULLP)
4890 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4894 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4895 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4896 if(e2apMsg->choice.initiatingMessage == NULLP)
4898 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4901 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4902 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
4903 e2apMsg->choice.initiatingMessage->value.present = \
4904 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
4905 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4908 if(e2NodeList->addE2NodeCount)
4910 if(e2NodeList->updateE2NodeCount)
4912 if(e2NodeList->removeE2NodeCount)
4915 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
4916 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
4917 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4918 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
4920 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4924 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
4926 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4927 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
4930 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4935 if(arrIdx<elementCnt)
4939 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4940 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4941 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
4942 transId = assignTransactionId();
4943 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4945 if(e2NodeList->addE2NodeCount)
4948 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
4949 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4950 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigAddition_List;
4951 if(BuildE2NodeConfigAddList(&(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List),\
4952 ProcedureCodeE2_id_E2nodeConfigurationUpdate, e2NodeList->addE2NodeCount, e2NodeList->addE2Node)!=ROK)
4954 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
4959 if(e2NodeList->updateE2NodeCount)
4962 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate;
4963 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4964 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigUpdate_List;
4965 if(BuildE2NodeConfigUpdateList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List,\
4966 e2NodeList->updateE2NodeCount, e2NodeList->updateE2Node) != ROK)
4969 DU_LOG("\nERROR --> E2AP : Failed to update the E2 node configuration");
4974 if(e2NodeList->removeE2NodeCount)
4977 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval;
4978 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4979 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigRemoval_List;
4980 if(BuildE2NodeConfigRemoveList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List,\
4981 e2NodeList->removeE2NodeCount, e2NodeList->removeE2Node) != ROK)
4984 DU_LOG("\nERROR --> E2AP : Failed to remove the E2 node configuration");
4989 /* Prints the Msg formed */
4990 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4992 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4994 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
4995 if(encRetVal.encoded == ENCODE_FAIL)
4997 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
4998 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5003 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
5004 #ifdef DEBUG_ASN_PRINT
5005 for(int i=0; i< encBufSize; i++)
5007 printf("%x",encBuf[i]);
5011 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
5013 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
5017 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5018 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5019 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.e2NodeConfigUpdate.configList, e2NodeList, sizeof(E2NodeConfigList));
5024 FreeE2NodeConfigUpdate(e2apMsg);
5028 /*******************************************************************
5030 * @brief Deallocate the memory allocated for E2ResetRequest msg
5034 * Function : FreeE2ResetRequest
5037 * - freeing the memory allocated for E2ResetRequest
5039 * @params[in] E2AP_PDU_t *e2apMsg
5040 * @return ROK - success
5043 * ****************************************************************/
5044 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
5047 ResetRequestE2_t *resetReq = NULLP;
5049 if(e2apMsg != NULLP)
5051 if(e2apMsg->choice.initiatingMessage != NULLP)
5053 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5054 if(resetReq->protocolIEs.list.array)
5056 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
5058 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5060 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5062 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5064 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5068 /*******************************************************************
5070 * @brief Build and send the E2 reset request msg
5074 * Function : BuildAndSendE2ResetRequest
5077 * - Buld and send the E2 reset request msg to RIC
5081 * @return ROK - success
5084 * ****************************************************************/
5085 uint8_t BuildAndSendE2ResetRequest(E2FailureCause resetCause)
5087 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
5088 uint8_t ret = RFAILED;
5089 E2AP_PDU_t *e2apMsg = NULLP;
5090 ResetRequestE2_t *resetReq = NULLP;
5091 asn_enc_rval_t encRetVal; /* Encoder return value */
5093 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
5097 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5098 if(e2apMsg == NULLP)
5100 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
5104 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5105 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5106 if(e2apMsg->choice.initiatingMessage == NULLP)
5108 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
5112 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
5113 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5114 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
5115 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5118 resetReq->protocolIEs.list.count = elementCnt;
5119 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
5121 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5122 if(!resetReq->protocolIEs.list.array)
5124 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5125 Reset Request IE array");
5129 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5131 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5132 if(!resetReq->protocolIEs.list.array[ieIdx])
5134 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5135 Reset Request IE array element");
5140 /* In case of failure */
5141 if(ieIdx < elementCnt)
5145 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5146 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
5147 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
5148 transId = assignTransactionId();
5149 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
5152 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
5153 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
5154 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
5155 fillE2Cause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, resetCause);
5157 /* Prints the Msg formed */
5158 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5160 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5162 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
5164 if(encRetVal.encoded == ENCODE_FAIL)
5166 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
5167 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5172 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
5173 #ifdef DEBUG_ASN_PRINT
5174 for(int i=0; i< encBufSize; i++)
5176 printf("%x",encBuf[i]);
5180 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5182 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5186 /* In case the message is sent successfully, store the transaction info to
5187 * be used when response is received */
5188 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5189 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5195 /* Free all memory */
5196 FreeE2ResetRequest(e2apMsg);
5200 /*******************************************************************
5202 * @brief Deallocate the memory allocated for Reset Response msg
5206 * Function : freeAperDecodingOfE2ResetRsp
5209 * - freeing the memory allocated for Reset response
5211 * @params[in] ResetResponseE2_t *resetResponse
5214 * ****************************************************************/
5215 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
5221 if(resetResponse->protocolIEs.list.array)
5223 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5225 if(resetResponse->protocolIEs.list.array[ieIdx])
5227 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5229 case ProtocolIE_IDE2_id_TransactionID:
5232 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5235 free(resetResponse->protocolIEs.list.array[ieIdx]);
5238 free(resetResponse->protocolIEs.list.array);
5243 /******************************************************************
5245 * @brief Processes E2 Reset Response sent by RIC
5249 * Function : procResetResponse
5251 * Functionality: Processes E2 Reset Response sent by RIC
5253 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5256 * ****************************************************************/
5257 void procResetResponse(E2AP_PDU_t *e2apMsg)
5259 bool invalidTransId=false;
5260 uint8_t ieIdx =0, transId =0;
5261 uint16_t ranFuncIdx=0;
5262 ResetResponseE2_t *resetResponse =NULLP;
5264 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
5265 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
5267 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5269 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5271 case ProtocolIE_IDE2_id_TransactionID:
5273 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5274 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \
5275 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
5277 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5281 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5282 invalidTransId = true;
5286 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5288 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
5290 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
5292 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
5293 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
5300 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
5301 resetResponse->protocolIEs.list.array[ieIdx]->id);
5306 if(invalidTransId == true)
5312 freeAperDecodingOfE2ResetRsp(resetResponse);
5315 /******************************************************************
5317 * @brief Deallocation of memory allocated by aper decoder for e2 setup Failure
5321 * Function : freeAperDecodingOfE2SetupFailure
5323 * Functionality: Deallocation of memory allocated by aper decoder for e2
5326 * @params[in] E2setupFailure_t *e2SetupFailure;
5329 * ****************************************************************/
5330 void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure)
5336 if(e2SetupFailure->protocolIEs.list.array)
5338 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5340 if(e2SetupFailure->protocolIEs.list.array[arrIdx])
5342 free(e2SetupFailure->protocolIEs.list.array[arrIdx]);
5345 free(e2SetupFailure->protocolIEs.list.array);
5349 /******************************************************************
5351 * @brief Processes E2 Setup Failure sent by RIC
5355 * Function : procE2SetupFailure
5357 * Functionality: Processes E2 Setup failure sent by RIC
5359 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5360 * @return ROK - success
5363 * ****************************************************************/
5364 void procE2SetupFailure(E2AP_PDU_t *e2apMsg)
5366 uint8_t arrIdx =0, transId =0, timerValue=0;
5367 E2setupFailure_t *e2SetupFailure;
5369 DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
5370 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
5372 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5374 switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id)
5376 case ProtocolIE_IDE2_id_TransactionID:
5378 transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5379 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
5380 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5382 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5386 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5391 case ProtocolIE_IDE2_id_TimeToWaitE2:
5393 timerValue = convertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
5394 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE)
5396 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue);
5400 DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
5408 freeAperDecodingOfE2SetupFailure(e2SetupFailure);
5410 /******************************************************************
5412 * @brief Deallocation of memory allocated by aper decoder for RIC service Query
5416 * Function : freeAperDecodingOfRicServiceQuery
5418 * Functionality: Deallocation of memory allocated by aper decoder for RIC
5421 * @params[in] RICserviceQuery_t *ricServiceQuery;
5424 * ****************************************************************/
5426 void freeAperDecodingOfRicServiceQuery(RICserviceQuery_t *ricServiceQuery)
5428 uint8_t arrIdx,ranFuncIdx;
5429 RANfunctionsID_List_t *ranFuncAddedList;
5433 if(ricServiceQuery->protocolIEs.list.array)
5435 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5437 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
5439 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5441 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5443 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5444 if(ranFuncAddedList->list.array)
5446 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5448 free(ranFuncAddedList->list.array[ranFuncIdx]);
5450 free(ranFuncAddedList->list.array);;
5457 free(ricServiceQuery->protocolIEs.list.array[arrIdx]);
5460 free(ricServiceQuery->protocolIEs.list.array);
5464 /*******************************************************************
5466 * @brief Build RanFunction Delete List
5470 * Function : BuildRanFunctionDeleteList
5472 * Functionality: Build RanFunction Delete List
5475 * RANfunctionsID List
5476 * Count of the RAN function
5477 * Received RAN function list
5479 * @return ROK - success
5482 ******************************************************************/
5484 uint8_t BuildRanFunctionDeleteList(RANfunctionsID_List_t *deleteList, uint8_t count, RanFuncInfo *recvdRanFunc)
5486 uint8_t ranFuncIdx=0;
5487 RANfunctionID_ItemIEs_t *delRanFuncItem;
5491 deleteList->list.count = count;
5492 deleteList->list.size = deleteList->list.count * sizeof(RANfunctionID_ItemIEs_t*);
5493 DU_ALLOC(deleteList->list.array, deleteList->list.size);
5494 if(deleteList->list.array == NULLP)
5496 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5499 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
5501 DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t));
5502 if(deleteList->list.array[ranFuncIdx] == NULLP)
5504 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5507 delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx];
5508 delRanFuncItem->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
5509 delRanFuncItem->criticality = CriticalityE2_ignore;
5510 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionID = recvdRanFunc[ranFuncIdx].id;
5511 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionRevision = recvdRanFunc[ranFuncIdx].revisionCounter;
5517 /*******************************************************************
5519 * @brief De Allocate Ric Service Update message
5523 * Function : FreeRicServiceUpdate
5525 * Functionality: De-Allocating Ric Service Update message
5527 * @params[in] E2AP_PDU_t *e2apMsg
5531 * ****************************************************************/
5533 void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg)
5536 uint8_t ranFuncAddListIdx=0, ranFuncDelIdx=0;
5537 RICserviceUpdate_t *ricServiceUpdate;
5538 RANfunctions_List_t *ranFunctionsList;
5539 RANfunction_ItemIEs_t *ranFuncItemIe;
5540 RANfunction_Item_t *ranFunItem;
5541 RANfunctionsID_List_t *deleteList;
5543 /* De-allocating Memory */
5544 if(e2apMsg != NULLP)
5546 if(e2apMsg->choice.initiatingMessage != NULLP)
5548 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5549 if(ricServiceUpdate->protocolIEs.list.array != NULLP)
5551 for(arrIdx = 0; arrIdx < ricServiceUpdate->protocolIEs.list.count; arrIdx++)
5553 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] != NULLP)
5555 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
5557 case ProtocolIE_IDE2_id_TransactionID:
5560 case ProtocolIE_IDE2_id_RANfunctionsAdded:
5561 case ProtocolIE_IDE2_id_RANfunctionsModified:
5563 ranFunctionsList = &(ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
5564 if(ranFunctionsList->list.array)
5566 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
5568 if(ranFunctionsList->list.array[ranFuncAddListIdx])
5570 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
5571 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
5572 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
5573 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
5574 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
5577 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
5581 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
5583 deleteList= &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5584 if(deleteList->list.array)
5586 for(ranFuncDelIdx = 0; ranFuncDelIdx< deleteList->list.count; ranFuncDelIdx++)
5588 DU_FREE(deleteList->list.array[ranFuncDelIdx], sizeof(RANfunctionID_ItemIEs_t));
5590 DU_FREE(deleteList->list.array, deleteList->list.size);
5596 DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
5597 (ricServiceUpdate->protocolIEs.list.array[arrIdx]->id));
5600 DU_FREE(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5603 DU_FREE(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5605 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5607 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5611 /*******************************************************************
5613 * @brief Builds and Send the RicServiceUpdateuest
5617 * Function : BuildAndSendRicServiceUpdate
5619 * Functionality:Fills the RicServiceUpdateuest
5621 * @return ROK - success
5624 ******************************************************************/
5626 uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate)
5628 uint8_t arrIdx = 0, elementCnt=0;
5629 uint8_t transId = 0, ret = RFAILED;
5630 bool memAllocFailed =false;
5631 E2AP_PDU_t *e2apMsg = NULLP;
5632 RICserviceUpdate_t *ricServiceUpdate = NULLP;
5633 asn_enc_rval_t encRetVal; /* Encoder return value */
5635 DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n");
5638 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5639 if(e2apMsg == NULLP)
5641 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5644 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5645 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5646 if(e2apMsg->choice.initiatingMessage == NULLP)
5648 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5651 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5652 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
5653 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceUpdate;
5654 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5656 /* For TransId IE, set elementCnt to 1.
5657 If there is any item in the RAN function add list, RAN function modification list, or RAN function delete list, increment the elementCnt.*/
5660 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5662 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5664 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5667 ricServiceUpdate->protocolIEs.list.count = elementCnt;
5668 ricServiceUpdate->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdate_IEs_t*);
5670 /* Initialize the E2Setup members */
5671 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5672 if(ricServiceUpdate->protocolIEs.list.array == NULLP)
5674 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
5678 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
5680 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5681 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP)
5683 memAllocFailed = true;
5684 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
5688 if(memAllocFailed == true)
5694 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5695 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5696 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
5697 if(serviceUpdate.dir == E2_NODE_INITIATED)
5698 transId = assignTransactionId();
5700 transId = serviceUpdate.transId;
5701 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5703 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5706 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
5707 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5708 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5709 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,\
5710 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded, serviceUpdate.recvRanFuncList.ranFunToBeAdded) !=ROK)
5716 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5719 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsModified;
5720 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5721 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5722 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,
5723 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeModified, serviceUpdate.recvRanFuncList.ranFunToBeModified) !=ROK)
5729 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5732 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsDeleted;
5733 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5734 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctionsID_List;
5735 if(BuildRanFunctionDeleteList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List,\
5736 serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted, serviceUpdate.recvRanFuncList.ranFunToBeDeleted) != ROK)
5741 /* Prints the Msg formed */
5742 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5744 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5746 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5747 if(encRetVal.encoded == ENCODE_FAIL)
5749 DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
5750 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5755 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
5756 #ifdef DEBUG_ASN_PRINT
5757 for(int i=0; i< encBufSize; i++)
5759 printf("%x",encBuf[i]);
5763 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5765 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5774 if(serviceUpdate.dir == E2_NODE_INITIATED)
5776 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5777 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5781 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId = transId;
5782 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5784 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.dir = serviceUpdate.dir;
5785 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.transId =transId;
5786 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.recvRanFuncList, &serviceUpdate.recvRanFuncList, sizeof(E2TmpRanFunList));
5788 FreeRicServiceUpdate(e2apMsg);
5791 /******************************************************************
5793 * @brief Processes RIC service Query sent by RIC
5797 * Function : procRicServiceQuery
5799 * Functionality: Processes RIC service Query sent by RIC
5801 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5802 * @return ROK - success
5805 * ****************************************************************/
5807 void procRicServiceQuery(E2AP_PDU_t *e2apMsg)
5810 uint16_t arrIdx =0, ranFuncIdx=0,tmpIdx=0;
5811 uint16_t id,revisionCcounter;
5812 bool tmpArray[MAX_RAN_FUNCTION] = {false};
5813 RICserviceQuery_t *ricServiceQuery=NULL;
5814 RicServiceUpdate ricUpdate;
5815 RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
5816 RANfunctionsID_List_t *ranFuncAddedList;
5818 DU_LOG("\nINFO --> E2AP : RIC Service Query received");
5819 memset(&ricUpdate, 0, sizeof(RicServiceUpdate));
5820 ricUpdate.dir = RIC_INITIATED;
5821 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
5823 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5825 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5827 /* TODO completing in next patch/gerrit */
5828 case ProtocolIE_IDE2_id_TransactionID:
5830 ricUpdate.transId = ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5834 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5836 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5837 if(ranFuncAddedList->list.array)
5839 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5841 if(ranFuncAddedList->list.array[ranFuncIdx])
5843 /* Using the RAN function Id, identify the RAN function to be modified or deleted. */
5845 ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
5846 id = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID;
5847 revisionCcounter = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision;
5849 if((id != duCb.e2apDb.ranFunction[id-1].id))
5851 action = CONFIG_DEL;
5853 else if((id == duCb.e2apDb.ranFunction[id-1].id)&&(revisionCcounter!=duCb.e2apDb.ranFunction[id-1].revisionCounter))
5855 action = CONFIG_MOD;
5858 if(action == CONFIG_DEL)
5860 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].id = id;
5861 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].revisionCounter = revisionCcounter;
5862 ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted++;
5864 else if(action == CONFIG_MOD)
5866 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].id = id;
5867 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].revisionCounter = revisionCcounter;
5868 ricUpdate.recvRanFuncList.numOfRanFunToBeModified++;
5871 /* If any ID is set to true, it means that the ID has been used in either modification or deletion list.
5872 * Else we will add the IDs into the added list */
5873 tmpArray[id-1] = true;
5882 /* Traversing the whole RAN function list in ducb to check if any new Ran function ids have been added. */
5883 for(arrIdx =0; arrIdx<MAX_RAN_FUNCTION; arrIdx++)
5885 tmpIdx= ricUpdate.recvRanFuncList.numOfRanFunToBeAdded;
5886 if((duCb.e2apDb.ranFunction[arrIdx].id >0)&&(!tmpArray[arrIdx]))
5888 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[arrIdx].id;
5889 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[arrIdx].revisionCounter;
5890 ricUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
5894 if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK)
5896 DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message");
5899 freeAperDecodingOfRicServiceQuery(ricServiceQuery);
5902 /******************************************************************
5904 * @brief Deallocation of memory allocated by aper decoder for
5905 * RIC service update ack
5909 * Function : freeAperDecodingOfRicServiceUpdateAck
5911 * Functionality: Deallocation of memory allocated by aper decoder
5912 * for RIC service update ack
5914 * @params[in] RICserviceUpdateAck_t *ricServiceAck;
5917 * ****************************************************************/
5919 void freeAperDecodingOfRicServiceUpdateAck(RICserviceUpdateAcknowledge_t *ricServiceAck)
5921 uint8_t arrIdx=0,ranFuncIdx=0;
5922 RANfunctionsID_List_t *ranFuncAddedList=NULL;
5926 if(ricServiceAck->protocolIEs.list.array)
5928 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5930 if(ricServiceAck->protocolIEs.list.array[arrIdx])
5932 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5934 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5936 ranFuncAddedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5937 if(ranFuncAddedList->list.array)
5939 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5941 free(ranFuncAddedList->list.array[ranFuncIdx]);
5943 free(ranFuncAddedList->list.array);
5950 free(ricServiceAck->protocolIEs.list.array[arrIdx]);
5953 free(ricServiceAck->protocolIEs.list.array);
5958 /******************************************************************
5960 * @brief Processes RIC service update ack sent by RIC
5964 * Function : procRicServiceUpdateAck
5966 * Functionality: Processes RIC service update ack sent by RIC
5968 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5969 * @return ROK - success
5972 * ****************************************************************/
5974 void procRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
5976 uint8_t arrIdx =0, transId =0;
5977 uint16_t id =0, tmpIdx=0, ranFuncIdx=0;
5978 RicServiceUpdate serviceUpdate;
5979 RANfunctionsIDcause_List_t *rejectedList=NULL;
5980 RICserviceUpdateAcknowledge_t *ricServiceAck=NULL;
5981 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
5983 DU_LOG("\nINFO --> E2AP : RIC service update ack received");
5984 memset(&serviceUpdate, 0, sizeof(RicServiceUpdate));
5985 ricServiceAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
5987 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5989 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5991 case ProtocolIE_IDE2_id_TransactionID:
5993 transId = ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5994 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
5995 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5997 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5999 else if((duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId == transId) &&\
6000 (duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
6002 memset(&duCb.e2apDb.e2TransInfo.ricInitTransaction[transId], 0, sizeof(E2TransInfo));
6006 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
6012 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
6015 case ProtocolIE_IDE2_id_RANfunctionsRejected:
6017 rejectedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
6018 if(rejectedList->list.array)
6020 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
6022 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)rejectedList->list.array[ranFuncIdx];
6023 id = ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID;
6024 tmpIdx= serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded;
6025 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[id-1].id;
6026 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[id-1].revisionCounter;
6027 serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
6036 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
6038 serviceUpdate.dir = E2_NODE_INITIATED;
6039 BuildAndSendRicServiceUpdate(serviceUpdate);
6041 freeAperDecodingOfRicServiceUpdateAck(ricServiceAck);
6044 /******************************************************************
6046 * @brief Deallocation of memory allocated by aper decoder for
6047 * RIC service update failure
6051 * Function : freeAperDecodingOfRicServiceUpdateFailure
6053 * Functionality: Deallocation of memory allocated by aper decoder
6054 * for RIC service update failure
6056 * @params[in] RICserviceUpdateFailure_t *ricServiceFailure;
6059 * ****************************************************************/
6061 void freeAperDecodingOfRicServiceUpdateFailure(RICserviceUpdateFailure_t *ricServiceFailure)
6065 if(ricServiceFailure)
6067 if(ricServiceFailure->protocolIEs.list.array)
6069 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6071 if(ricServiceFailure->protocolIEs.list.array[arrIdx])
6073 free(ricServiceFailure->protocolIEs.list.array[arrIdx]);
6076 free(ricServiceFailure->protocolIEs.list.array);
6081 /******************************************************************
6083 * @brief Processes RIC service update failure sent by RIC
6087 * Function : procRicServiceUpdateFailure
6089 * Functionality: Processes RIC service update failure sent by RIC
6091 * @params[in] E2AP_PDU_t ASN decoded E2AP message
6092 * @return ROK - success
6095 * ****************************************************************/
6097 void procRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
6099 uint8_t arrIdx =0, timerValue=0;
6100 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
6102 DU_LOG("\nINFO --> E2AP : RIC service update failure received");
6103 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
6105 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6107 switch(ricServiceFailure->protocolIEs.list.array[arrIdx]->id)
6109 case ProtocolIE_IDE2_id_TransactionID:
6113 case ProtocolIE_IDE2_id_TimeToWaitE2:
6115 timerValue = convertE2WaitTimerEnumToValue(ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
6116 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR)) == FALSE)
6118 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR, timerValue);
6122 DU_LOG("\nERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running");
6127 case ProtocolIE_IDE2_id_CauseE2:
6134 freeAperDecodingOfRicServiceUpdateFailure(ricServiceFailure);
6137 /******************************************************************
6139 * @brief DU Send E2 Node Configuration Update
6143 * Function : duSendE2NodeConfigurationUpdate
6145 * Functionality: DU Send E2 Node Configuration Update
6147 * @return ROK - success
6150 * ****************************************************************/
6152 uint8_t duSendE2NodeConfigurationUpdate()
6154 E2NodeConfigList e2NodeList;
6155 CmLList *node =NULL;
6156 E2NodeComponent *e2NodeComponentInfo=NULL;
6158 memset(&e2NodeList, 0, sizeof(E2NodeConfigList));
6159 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
6162 e2NodeComponentInfo = (E2NodeComponent*)node->node;
6164 if(e2NodeComponentInfo->addConfiguration)
6166 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6167 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6168 e2NodeList.addE2NodeCount++;
6171 if(e2NodeComponentInfo->updateConfiguration)
6173 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6174 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6175 e2NodeList.updateE2NodeCount++;
6178 if(e2NodeComponentInfo->deleteConfiguration == true)
6180 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6181 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].componentId = e2NodeComponentInfo->componentId;
6182 e2NodeList.removeE2NodeCount++;
6188 if(BuildAndSendE2NodeConfigUpdate(&e2NodeList) !=ROK)
6190 DU_LOG("\nERROR --> E2AP : Failed to build and send e2 node config update message to RIC_stub");
6196 /*******************************************************************
6198 * @brief Free RIC Subscription Modification Required
6202 * Function : FreeRicSubsModRequired
6204 * Functionality: Freqq RIC Subscription Modification required
6206 * @param E2AP Message PDU to be freed
6209 ******************************************************************/
6210 void FreeRicSubsModRequired(E2AP_PDU_t *e2apMsg)
6212 uint8_t ieIdx = 0, arrIdx = 0;
6213 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6214 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6215 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6216 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6220 if(e2apMsg->choice.initiatingMessage)
6222 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6223 if(ricSubsModReqd->protocolIEs.list.array)
6225 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
6227 if(ricSubsModReqd->protocolIEs.list.array[ieIdx])
6229 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6230 switch(ricSubsModReqdIe->id)
6232 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
6234 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6235 if(actionToBeModList->list.array)
6237 for(arrIdx = 0; arrIdx < actionToBeModList->list.count; arrIdx++)
6239 DU_FREE(actionToBeModList->list.array[arrIdx], \
6240 sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6242 DU_FREE(actionToBeModList->list.array, actionToBeModList->list.size);
6247 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
6249 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6250 if(actionToBeRmvList->list.array)
6252 for(arrIdx = 0; arrIdx < actionToBeRmvList->list.count; arrIdx++)
6254 DU_FREE(actionToBeRmvList->list.array[arrIdx], \
6255 sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6257 DU_FREE(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6265 DU_FREE(ricSubsModReqd->protocolIEs.list.array[ieIdx], \
6266 sizeof(RICsubscriptionModificationRequired_IEs_t));
6269 DU_FREE(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6271 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6273 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6277 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6278 * However, E2SM-KPM supports only RIC Report service.
6279 * Hence there is no subsequent action in RIC subscription that may require modification.
6280 * So commenting the action-modification IEs for the time being
6283 /*******************************************************************
6285 * @brief Fill Action required to be modified list
6289 * Function : FillActionReqdToBeModList
6291 * Functionality: Fill Action required to be modified list
6293 * @param RIC Actions Required To Be Modified List to be filled
6294 * Number of actions to be modified
6295 * RIC Subscription DB
6296 * @return ROK - success
6299 ******************************************************************/
6300 uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod,\
6301 RicSubscription *ricSubscription)
6304 CmLList *actionNode = NULLP;
6305 ActionInfo *actionDb = NULLP;
6306 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL;
6308 actionToBeModList->list.count = numActionsMod;
6309 actionToBeModList->list.size = numActionsMod * sizeof(RICaction_RequiredToBeModified_ItemIEs_t *);
6310 DU_ALLOC(actionToBeModList->list.array, actionToBeModList->list.size);
6311 if(!actionToBeModList->list.array)
6313 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6318 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6321 actionDb = (ActionInfo*)(actionNode->node);
6322 if(actionDb->action == CONFIG_MOD)
6324 DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6325 if(!actionToBeModList->list.array[arrIdx])
6327 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6330 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[arrIdx];
6332 actionToBeMod->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeModified_Item;
6333 actionToBeMod->criticality = CriticalityE2_reject;
6334 actionToBeMod->value.present = \
6335 RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item;
6336 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \
6338 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms;
6347 /*******************************************************************
6349 * @brief Fill Action required to be removed list
6353 * Function : FillActionReqdToBeRmvList
6355 * Functionality: Fill Action required to be removed list
6357 * @param RIC Actions Required To Be Removed List to be filled
6358 * Number of actions to be removed
6359 * RIC Subscription DB
6360 * @return ROK - success
6363 ******************************************************************/
6364 uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \
6365 RicSubscription *ricSubscription)
6368 CmLList *actionNode = NULLP;
6369 ActionInfo *actionDb = NULLP;
6370 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL;
6372 actionToBeRmvList->list.count = numActionsRmv;
6373 actionToBeRmvList->list.size = numActionsRmv * sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t *);
6374 DU_ALLOC(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6375 if(!actionToBeRmvList->list.array)
6377 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6382 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6385 actionDb = (ActionInfo*)(actionNode->node);
6386 if(actionDb->action == CONFIG_DEL)
6388 DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6389 if(!actionToBeRmvList->list.array[arrIdx])
6391 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6394 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[arrIdx];
6396 actionToBeRmv->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeRemoved_Item;
6397 actionToBeRmv->criticality = CriticalityE2_reject;
6398 actionToBeRmv->value.present = \
6399 RICaction_RequiredToBeRemoved_ItemIEs__value_PR_RICaction_RequiredToBeRemoved_Item;
6400 actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = actionDb->actionId;
6401 fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, actionDb->failureCause);
6409 /*******************************************************************
6411 * @brief Fill RIC Subscription Modification Required IEs
6415 * Function : FillRicSubsModRequired
6417 * Functionality: Fill RIC Subscription Modification Required IEs
6419 * @param RIC Subscription Modification Required IEs to be filled
6420 * RIC Subscription DB
6421 * @return ROK - success
6424 ******************************************************************/
6425 uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription)
6427 ActionInfo * actionDb=NULLP;
6428 CmLList *actionNode = NULLP;
6429 uint8_t ieIdx = 0, elementCnt=0;
6430 uint8_t numActionsMod = 0, numActionsRmv = 0;
6431 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6432 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6434 /* Unused in case of E2SM-KPM */
6436 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6439 /* Count number of Actions to be modified or deleted */
6440 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6443 actionDb = (ActionInfo*)(actionNode->node);
6444 if(actionDb->action == CONFIG_MOD)
6446 else if(actionDb->action == CONFIG_DEL)
6448 actionNode = actionNode->next;
6451 /* Count number of IEs to be added to messages */
6458 ricSubsModReqd->protocolIEs.list.count = elementCnt;
6459 ricSubsModReqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequired_IEs_t *);
6460 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6461 if(!ricSubsModReqd->protocolIEs.list.array)
6463 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6467 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
6469 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRequired_IEs_t));
6470 if(!ricSubsModReqd->protocolIEs.list.array[ieIdx])
6472 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6477 /* RIC Request ID */
6479 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6480 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICrequestID;
6481 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6482 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RICrequestID;
6483 ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID = ricSubscription->requestId.requestorId;
6484 ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID = ricSubscription->requestId.instanceId;
6486 /* RAN Function ID */
6488 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6489 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RANfunctionID;
6490 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6491 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RANfunctionID;
6492 ricSubsModReqdIe->value.choice.RANfunctionID = ricSubscription->ranFuncId;
6494 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6495 * However, E2SM-KPM supports only RIC Report service.
6496 * Hence there is no subsequent action in RIC subscription that may require modification.
6497 * So commenting the action-modification IEs for the time being
6500 /* RIC Actions Required to be Modified */
6504 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6505 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List;
6506 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6507 ricSubsModReqdIe->value.present = \
6508 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeModified_List;
6509 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6511 if(FillActionReqdToBeModList(actionToBeModList, numActionsMod, ricSubscription) != ROK)
6513 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__);
6519 /* RIC Actions Required to be removed */
6523 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6524 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List;
6525 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6526 ricSubsModReqdIe->value.present = \
6527 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeRemoved_List;
6528 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6530 if(FillActionReqdToBeRmvList(actionToBeRmvList, numActionsRmv, ricSubscription) != ROK)
6532 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__);
6540 /*******************************************************************
6542 * @brief Builds and Send RIC Subscription Modification Required
6547 * Function : BuildAndSendRicSubsModRequired
6549 * Functionality: Builds and Send RIC Subscription Modification
6552 * @param RIC Subscription DB
6553 * @return ROK - success
6556 ******************************************************************/
6557 uint8_t BuildAndSendRicSubsModRequired(RicSubscription *ricSubscription)
6559 uint8_t ret = RFAILED;
6560 E2AP_PDU_t *e2apMsg = NULLP;
6561 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6562 asn_enc_rval_t encRetVal; /* Encoder return value */
6564 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Required \n");
6567 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6568 if(e2apMsg == NULLP)
6570 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6574 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6575 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6576 if(e2apMsg->choice.initiatingMessage == NULLP)
6578 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6581 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6582 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
6583 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired;
6585 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6587 if(FillRicSubsModRequired(ricSubsModReqd, ricSubscription) != ROK)
6589 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__);
6594 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6596 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6598 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6599 if(encRetVal.encoded == ENCODE_FAIL)
6601 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modifiction Required structure (at %s)\n",\
6602 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6607 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Required \n");
6608 #ifdef DEBUG_ASN_PRINT
6609 for(int i=0; i< encBufSize; i++)
6611 printf("%x",encBuf[i]);
6615 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
6617 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Modification Required failed");
6624 /* Free RIC Subscription modification required */
6625 FreeRicSubsModRequired(e2apMsg);
6629 /*******************************************************************
6631 * @brief Free APER decoding of RIC Subscription Modification Confirm
6635 * Function : freeAperDecodingOfRicSubsModConfirm
6637 * Functionality: Free APER decoding of RIC Subscription
6638 * Modification Confirm
6640 * @param E2AP Message PDU
6643 ******************************************************************/
6644 void freeAperDecodingOfRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
6646 uint8_t ieIdx = 0, arrIdx=0;
6647 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6648 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6649 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6650 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6651 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6652 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6654 if(e2apMsg && e2apMsg->choice.successfulOutcome)
6656 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6657 if(ricSubsModCfm->protocolIEs.list.array)
6659 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6661 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
6663 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6664 switch(ricSubsModCfmIe->id)
6666 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6668 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6669 if(modCfmList->list.array)
6671 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6673 if(modCfmList->list.array[arrIdx])
6674 free(modCfmList->list.array[arrIdx]);
6676 free(modCfmList->list.array);
6681 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6683 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6684 if(modRefusedList->list.array)
6686 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6688 if(modRefusedList->list.array[arrIdx])
6689 free(modRefusedList->list.array[arrIdx]);
6691 free(modRefusedList->list.array);
6696 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6698 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6699 if(rmvCfmList->list.array)
6701 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6703 if(rmvCfmList->list.array[arrIdx])
6704 free(rmvCfmList->list.array[arrIdx]);
6706 free(rmvCfmList->list.array);
6711 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6713 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6714 if(rmvFailList->list.array)
6716 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6718 if(rmvFailList->list.array[arrIdx])
6719 free(rmvFailList->list.array[arrIdx]);
6721 free(rmvFailList->list.array);
6730 free(ricSubsModCfmIe);
6733 free(ricSubsModCfm->protocolIEs.list.array);
6738 /*******************************************************************
6740 * @brief Process RIC Subscription Modification Confirm Message
6744 * Function : procRicSubscriptionModificationConfirm
6746 * Functionality: Process RIC Subscription Modification Confirm
6747 * Message received from RIC.
6749 * @param E2AP Message PDU
6752 ******************************************************************/
6753 void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg)
6755 uint8_t actionId = 0, ieIdx = 0, arrIdx = 0;
6756 uint16_t ranFuncId = 0;
6757 bool procFailure = false;
6758 RicRequestId ricReqId;
6759 RanFunction *ranFuncDb = NULLP;
6760 CmLList *ricSubsNode = NULLP;
6761 CmLList *actionNode= NULLP;
6762 RicSubscription *ricSubsDb = NULLP;
6763 ActionInfo *actionDb = NULLP;
6765 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6766 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6768 /* Not used in case of E2SM-KPM */
6770 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6771 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
6773 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6774 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
6777 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6778 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
6780 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6781 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
6783 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Confirm", __func__);
6788 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
6792 if(!e2apMsg->choice.successfulOutcome)
6794 DU_LOG("\nERROR --> E2AP : %s: Successful Outcome in E2AP message is NULL", __func__);
6798 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6799 if(!ricSubsModCfm->protocolIEs.list.array)
6801 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
6805 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6807 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
6809 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
6813 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6814 switch(ricSubsModCfmIe->id)
6816 case ProtocolIE_IDE2_id_RICrequestID:
6818 memset(&ricReqId, 0, sizeof(RicRequestId));
6819 ricReqId.requestorId = ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID;
6820 ricReqId.instanceId = ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID;
6824 case ProtocolIE_IDE2_id_RANfunctionID:
6826 ranFuncId = ricSubsModCfmIe->value.choice.RANfunctionID;
6827 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
6830 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
6835 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
6838 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
6839 __func__, ricReqId.requestorId, ricReqId.instanceId);
6847 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6848 * However, E2SM-KPM supports only RIC Report service.
6849 * Hence there is no subsequent action in RIC subscription that may require modification.
6850 * So commenting the action-modification IEs for the time being
6853 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6855 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6856 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6858 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
6859 actionId = modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID;
6861 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode);
6864 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6868 actionDb->action = CONFIG_UNKNOWN;
6869 /* Further handling can be added here in future once the
6870 * use case of this procedure is identified */
6877 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6879 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6880 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6882 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
6883 actionId = modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID;
6884 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode);
6887 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6891 /* Spec doesnt mention if in case of failure, DU should retry for modify action
6892 * Hence, chaging the action from CONFIG_MOD to CONFIG_UNKNOWN
6894 actionDb->action = CONFIG_UNKNOWN;
6902 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6904 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6905 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6907 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
6908 actionId = rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID;
6909 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode);
6912 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6916 deleteActionSequence(actionNode);
6918 /* Further handling can include :
6919 * Deletion of this action from all DU layers
6927 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6929 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6930 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6932 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
6933 actionId = rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID;
6934 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode);
6937 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6941 actionDb->action = CONFIG_UNKNOWN;
6950 } /* End of switch for Protocol IE Id */
6954 } /* End of for loop for Protocol IE list */
6959 freeAperDecodingOfRicSubsModConfirm(e2apMsg);
6963 /******************************************************************
6964 * @brief Deallocate the memory allocated for E2 Reset Response
6968 * Function : FreeE2ResetResponse
6971 * - freeing the memory allocated for E2ResetResponse
6973 * @params[in] E2AP_PDU_t *e2apMsg
6974 * @return ROK - success
6977 * ****************************************************************/
6978 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
6981 ResetResponseE2_t *resetResponse;
6983 if(e2apMsg != NULLP)
6985 if(e2apMsg->choice.successfulOutcome != NULLP)
6987 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
6988 if(resetResponse->protocolIEs.list.array)
6990 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
6992 if(resetResponse->protocolIEs.list.array[ieIdx])
6994 DU_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
6997 DU_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
7000 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7002 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
7006 /*******************************************************************
7008 * @brief Buld and send the E2 Reset Response msg
7012 * Function : BuildAndSendE2ResetResponse
7015 * - Buld and send the E2 Reset Response Message
7017 * @params[in] Trans Id
7018 * @return ROK - success
7021 * ****************************************************************/
7022 uint8_t BuildAndSendResetResponse(uint8_t transId)
7024 uint8_t ieIdx = 0, elementCnt = 0;
7025 uint8_t ret = RFAILED;
7026 E2AP_PDU_t *e2apMsg = NULLP;
7027 ResetResponseE2_t *resetResponse;
7028 asn_enc_rval_t encRetVal; /* Encoder return value */
7030 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
7033 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7034 if(e2apMsg == NULLP)
7036 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
7039 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7041 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7042 if(e2apMsg->choice.successfulOutcome == NULLP)
7044 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
7048 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
7049 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7050 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
7051 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
7054 resetResponse->protocolIEs.list.count = elementCnt;
7055 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
7056 DU_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
7057 if(!resetResponse->protocolIEs.list.array)
7059 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
7063 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
7065 DU_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
7066 if(!resetResponse->protocolIEs.list.array[ieIdx])
7068 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
7072 if(ieIdx < elementCnt)
7076 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
7077 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
7078 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
7079 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
7081 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7083 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7085 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7086 if(encRetVal.encoded == ENCODE_FAIL)
7088 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
7089 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7094 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
7095 for(int i=0; i< encBufSize; i++)
7097 DU_LOG("%x",encBuf[i]);
7102 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7104 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
7112 FreeE2ResetResponse(e2apMsg);
7116 /******************************************************************
7118 * @brief Deallocation of memory allocated by aper decoder for reset req
7122 * Function : freeAperDecodingOfE2ResetReq
7124 * Functionality: Deallocation of memory allocated by aper decoder for
7127 * @params[in] Pointer to resetReq
7130 * ****************************************************************/
7131 void freeAperDecodingOfE2ResetReq(ResetRequestE2_t *resetReq)
7137 if(resetReq->protocolIEs.list.array)
7139 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7141 if(resetReq->protocolIEs.list.array[arrIdx])
7143 free(resetReq->protocolIEs.list.array[arrIdx]);
7146 free(resetReq->protocolIEs.list.array);
7151 /*******************************************************************
7153 * @brief Process reset req received from RIC
7157 * Function : procE2ResetRequest
7159 * Functionality: Process reset req received from RIC
7161 * @param E2AP_PDU_t *e2apMsg
7164 ******************************************************************/
7166 void procE2ResetRequest(E2AP_PDU_t *e2apMsg)
7168 uint16_t ranFuncIdx=0;
7169 uint8_t arrIdx =0, transId =0;
7170 ResetRequestE2_t *resetReq;
7172 DU_LOG("\nINFO --> E2AP : E2 Reset request received");
7173 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
7175 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7177 switch(resetReq->protocolIEs.list.array[arrIdx]->id)
7179 case ProtocolIE_IDE2_id_TransactionID:
7181 transId = resetReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
7185 case ProtocolIE_IDE2_id_CauseE2:
7187 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
7189 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
7191 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
7192 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
7199 if(BuildAndSendResetResponse(transId) != ROK)
7201 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
7203 freeAperDecodingOfE2ResetReq(resetReq);
7206 /*******************************************************************
7208 * @brief Free APER decoding of RIC Subscription Modification Refuse
7212 * Function : freeAperDecodingOfRicSubsModRefuse
7214 * Functionality: Free APER decoding of RIC Subscription
7215 * Modification Refuse
7217 * @param E2AP Message PDU
7220 ******************************************************************/
7221 void freeAperDecodingOfRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
7224 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7226 if(e2apMsg && e2apMsg->choice.unsuccessfulOutcome)
7228 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7229 if(ricSubsModRefuse->protocolIEs.list.array)
7231 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7233 if(ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7234 free(ricSubsModRefuse->protocolIEs.list.array[ieIdx]);
7236 free(ricSubsModRefuse->protocolIEs.list.array);
7241 /*******************************************************************
7243 * @brief Process RIC Subscription Modification Refuse Message
7247 * Function : procRicSubscriptionModificationRefuse
7249 * Functionality: Process RIC Subscription Modification Refuse
7250 * Message received from RIC.
7252 * @param E2AP Message PDU
7255 ******************************************************************/
7256 void procRicSubscriptionModificationRefuse(E2AP_PDU_t *e2apMsg)
7259 uint16_t ranFuncId = 0;
7260 RicRequestId ricReqId;
7261 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7262 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
7263 CauseE2_t *cause = NULLP;
7265 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Refuse", __func__);
7270 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
7274 if(!e2apMsg->choice.unsuccessfulOutcome)
7276 DU_LOG("\nERROR --> E2AP : %s: Unsuccessful Outcome in E2AP message is NULL", __func__);
7280 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7281 if(!ricSubsModRefuse->protocolIEs.list.array)
7283 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
7287 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7289 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7291 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
7295 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
7296 switch(ricSubsModRefuseIe->id)
7298 case ProtocolIE_IDE2_id_RICrequestID:
7300 memset(&ricReqId, 0, sizeof(RicRequestId));
7301 ricReqId.requestorId = ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID;
7302 ricReqId.instanceId = ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID;
7306 case ProtocolIE_IDE2_id_RANfunctionID:
7308 ranFuncId = ricSubsModRefuseIe->value.choice.RANfunctionID;
7312 case ProtocolIE_IDE2_id_CauseE2:
7314 DU_LOG("\nDEBUG --> E2AP : %s: RIC subscriptiom modification refused for RIC_Requestor_ID [%d] \
7315 RIC_Instance_ID [%d] RAN_Function_ID [%d] ", __func__, ricReqId.requestorId, \
7316 ricReqId.instanceId, ranFuncId);
7318 cause = &ricSubsModRefuseIe->value.choice.CauseE2;
7319 printE2ErrorCause(cause);
7324 } /* End of switch for Protocol IE Id */
7325 } /* End of for loop for Protocol IE list */
7330 freeAperDecodingOfRicSubsModRefuse(e2apMsg);
7334 /*******************************************************************
7336 * @brief Free RIC Subscription Delete Required Message
7340 * Function : FreeRicSubscriptionDeleteRequired
7342 * Functionality: Free RIC Subscription Delete Required
7344 * @param E2AP Message PDU
7347 ******************************************************************/
7348 void FreeRicSubscriptionDeleteRequired(E2AP_PDU_t *e2apMsg, CmLListCp *ricSubsToBeDelList)
7350 uint8_t ieIdx = 0, arrIdx = 0;
7351 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7352 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7353 RICsubscription_List_withCause_t *ricSubsList = NULLP;
7354 CmLList *subsNode = NULLP;
7358 if(e2apMsg->choice.initiatingMessage)
7360 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7361 if(ricSubsDelRqd->protocolIEs.list.array)
7363 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
7365 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx])
7367 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7368 switch(ricSubsDelRqdIe->id)
7370 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
7372 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
7373 if(ricSubsList->list.array)
7375 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
7377 DU_FREE(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7379 DU_FREE(ricSubsList->list.array, ricSubsList->list.size);
7384 DU_FREE(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7387 DU_FREE(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7389 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7391 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7394 if(ricSubsToBeDelList)
7396 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7399 cmLListDelFrm(ricSubsToBeDelList, subsNode);
7400 DU_FREE(subsNode, sizeof(CmLList));
7401 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7406 /*******************************************************************
7408 * @brief Fill list of RIC subscriptions required to be deleted
7409 * with the cause of deletion
7413 * Function : fillRicSubsListWithCause
7415 * Functionality: Fill list of RIC subscriptions required to be
7416 * deleted with the cause of deletion
7418 * @param E2AP Message PDU
7421 ******************************************************************/
7422 uint8_t fillRicSubsListWithCause(RICsubscription_List_withCause_t *ricSubsList, CmLListCp ricSubsToBeDelList)
7425 CmLList *subsNode = NULLP;
7426 RicSubscription *subsInfo = NULLP;
7427 RICsubscription_withCause_ItemIEs_t *subsItemIe = NULLP;
7428 RICsubscription_withCause_Item_t *subsItem = NULLP;
7430 ricSubsList->list.count = ricSubsToBeDelList.count;
7431 ricSubsList->list.size = ricSubsList->list.count * sizeof(RICsubscription_withCause_ItemIEs_t *);
7432 DU_ALLOC(ricSubsList->list.array, ricSubsList->list.size);
7433 if(!ricSubsList->list.array)
7435 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7439 CM_LLIST_FIRST_NODE(&ricSubsToBeDelList, subsNode);
7440 while(subsNode && (ieIdx < ricSubsList->list.count))
7442 subsInfo = (RicSubscription *)subsNode->node;
7443 DU_ALLOC(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7444 if(!ricSubsList->list.array[ieIdx])
7446 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7450 subsItemIe = (RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[ieIdx];
7451 subsItemIe->id = ProtocolIE_IDE2_id_RICsubscription_withCause_Item;
7452 subsItemIe->criticality = CriticalityE2_ignore;
7453 subsItemIe->value.present = RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item;
7455 subsItem = & subsItemIe->value.choice.RICsubscription_withCause_Item;
7456 subsItem->ricRequestID.ricRequestorID = subsInfo->requestId.requestorId;
7457 subsItem->ricRequestID.ricInstanceID = subsInfo->requestId.instanceId;
7458 subsItem->ranFunctionID = subsInfo->ranFuncId;
7459 fillE2Cause(&subsItem->cause, subsInfo->failureCause);
7462 subsNode = subsNode->next;
7468 /*******************************************************************
7470 * @brief Builds and Send RIC Subscription delete required
7474 * Function : BuildAndSendRicSubscriptionDeleteRequired
7476 * Functionality: Build and send RIC subscription delete required.
7477 * There can be 2 approaches to trigger following. One of these
7478 * approaches may/may not be implemented in future:
7479 * 1. It can be triggerred immediately when a RIC subscription's
7480 * End Time has expired. In this case, only this subscription's
7481 * info will be sent in this message.
7482 * Since we have not yet added support to execute RIC
7483 * Subscription based on Start Time and End Timer, this message is
7484 * not triggered anywhere from DU APP yet.
7485 * 2. Another approach is to have a periodic timer to check subscription
7486 * status running in background.
7487 * When RIC Subscription End Time expires, this subscription is
7488 * marked to be deleted. Later when this background timer expires,
7489 * a RIC Subscription delete required is sent with all the
7490 * subscription's info which is marked to be deleted.
7491 * The following function is implemented keeping in mind the second
7495 * @return ROK - success
7498 ******************************************************************/
7499 uint8_t BuildAndSendRicSubscriptionDeleteRequired()
7501 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7502 E2AP_PDU_t *e2apMsg = NULLP;
7503 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7504 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7505 asn_enc_rval_t encRetVal; /* Encoder return value */
7506 CmLListCp ricSubsToBeDelList;
7510 /* Check if there are any RIC subscriptions to be deleted */
7511 cmLListInit(&ricSubsToBeDelList);
7512 fetchRicSubsToBeDeleted(&ricSubsToBeDelList);
7513 if(ricSubsToBeDelList.count == 0)
7515 DU_LOG("\nDEBUG --> E2AP : %s: No RIC subscriptions are required to be deleted", __func__);
7519 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Required Message\n");
7521 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7522 if(e2apMsg == NULLP)
7524 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7528 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
7529 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7530 if(e2apMsg->choice.initiatingMessage == NULLP)
7532 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7535 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDeleteRequired;
7536 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
7537 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired;
7539 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7542 ricSubsDelRqd->protocolIEs.list.count = elementCnt;
7543 ricSubsDelRqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequired_IEs_t *);
7545 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7546 if(ricSubsDelRqd->protocolIEs.list.array == NULLP)
7548 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7552 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7554 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7555 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx] == NULLP)
7557 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7558 __func__, ieIdx, __LINE__);
7562 if(ieIdx < elementCnt)
7566 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7567 ricSubsDelRqdIe->id = ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved;
7568 ricSubsDelRqdIe->criticality = CriticalityE2_ignore;
7569 ricSubsDelRqdIe->value.present = RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause;
7570 if(fillRicSubsListWithCause(&ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause, ricSubsToBeDelList)\
7573 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription list with cause", __func__);
7577 /* Prints the Msg formed */
7578 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7579 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7581 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7582 if(encRetVal.encoded == ENCODE_FAIL)
7584 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Required Message (at %s)\n",\
7585 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7590 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Required Message \n");
7591 #ifdef DEBUG_ASN_PRINT
7592 for(int i=0; i< encBufSize; i++)
7594 printf("%x",encBuf[i]);
7599 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7601 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Required Message");
7608 FreeRicSubscriptionDeleteRequired(e2apMsg, &ricSubsToBeDelList);
7612 /*******************************************************************
7614 * @brief Free RIC Subscription Delete Failure Message
7618 * Function : FreeRicSubscriptionDeleteFailure
7620 * Functionality: Free RIC Subscription Delete Failure
7622 * @param E2AP Message PDU
7625 ******************************************************************/
7626 void FreeRicSubscriptionDeleteFailure(E2AP_PDU_t *e2apMsg)
7629 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7633 if(e2apMsg->choice.unsuccessfulOutcome)
7635 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7636 if(ricSubsDelFailure->protocolIEs.list.array)
7638 for(ieIdx = 0; ieIdx < ricSubsDelFailure->protocolIEs.list.count; ieIdx++)
7640 DU_FREE(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7642 DU_FREE(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7644 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7646 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7650 /*******************************************************************
7652 * @brief Builds and Send RIC Subscription Delete Failure
7656 * Function : BuildAndSendRicSubscriptionDeleteFailure
7658 * Functionality: Build and send RIC Subscription Delete Failure.
7664 * @return ROK - success
7667 ******************************************************************/
7668 uint8_t BuildAndSendRicSubscriptionDeleteFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
7670 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7671 E2AP_PDU_t *e2apMsg = NULLP;
7672 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7673 RICsubscriptionDeleteFailure_IEs_t *ricSubsDelFailureIe = NULLP;
7674 asn_enc_rval_t encRetVal; /* Encoder return value */
7678 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Failure Message\n");
7680 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7681 if(e2apMsg == NULLP)
7683 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7687 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
7688 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7689 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
7691 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7694 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7695 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
7696 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteFailure;
7699 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7702 ricSubsDelFailure->protocolIEs.list.count = elementCnt;
7703 ricSubsDelFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteFailure_IEs_t *);
7705 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7706 if(ricSubsDelFailure->protocolIEs.list.array == NULLP)
7708 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7712 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7714 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7715 if(ricSubsDelFailure->protocolIEs.list.array[ieIdx] == NULLP)
7717 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7718 __func__, ieIdx, __LINE__);
7722 if(ieIdx < elementCnt)
7726 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7727 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
7728 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7729 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
7730 ricSubsDelFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7731 ricSubsDelFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7734 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7735 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7736 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7737 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
7738 ricSubsDelFailureIe->value.choice.RANfunctionID = ranFuncId;
7741 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7742 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
7743 ricSubsDelFailureIe->criticality = CriticalityE2_ignore;
7744 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_CauseE2;
7745 fillE2Cause(&ricSubsDelFailureIe->value.choice.CauseE2, failureCause);
7747 /* Prints the Msg formed */
7748 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7749 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7751 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7752 if(encRetVal.encoded == ENCODE_FAIL)
7754 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Failure Message (at %s)\n",\
7755 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7760 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Failure Message \n");
7761 #ifdef DEBUG_ASN_PRINT
7762 for(int i=0; i< encBufSize; i++)
7764 printf("%x",encBuf[i]);
7769 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7771 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Failure Message");
7779 FreeRicSubscriptionDeleteFailure(e2apMsg);
7784 /*******************************************************************
7786 * @brief Free RIC Subscription Delete Response Message
7790 * Function : FreeRicSubscriptionDeleteResponse
7792 * Functionality: Free RIC Subscription Delete Response
7794 * @param E2AP Message PDU
7797 ******************************************************************/
7798 void FreeRicSubscriptionDeleteResponse(E2AP_PDU_t *e2apMsg)
7801 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7805 if(e2apMsg->choice.successfulOutcome)
7807 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7808 if(ricSubsDelRsp->protocolIEs.list.array)
7810 for(ieIdx = 0; ieIdx < ricSubsDelRsp->protocolIEs.list.count; ieIdx++)
7812 DU_FREE(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7814 DU_FREE(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7816 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7818 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7822 /*******************************************************************
7824 * @brief Builds and Send RIC Subscription delete Response
7828 * Function : BuildAndSendRicSubscriptionDeleteResponse
7830 * Functionality: Build and send RIC subscription delete Response.
7835 * @return ROK - success
7838 ******************************************************************/
7839 uint8_t BuildAndSendRicSubscriptionDeleteResponse(uint16_t ranFuncId, RicRequestId requestId)
7841 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7842 E2AP_PDU_t *e2apMsg = NULLP;
7843 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7844 RICsubscriptionDeleteResponse_IEs_t *ricSubsDelRspIe = NULLP;
7845 asn_enc_rval_t encRetVal; /* Encoder return value */
7849 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Response Message\n");
7851 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7852 if(e2apMsg == NULLP)
7854 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7858 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7859 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7860 if(e2apMsg->choice.successfulOutcome == NULLP)
7862 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7865 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7866 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7867 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse;
7870 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7873 ricSubsDelRsp->protocolIEs.list.count = elementCnt;
7874 ricSubsDelRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteResponse_IEs_t *);
7876 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7877 if(ricSubsDelRsp->protocolIEs.list.array == NULLP)
7879 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7883 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7885 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7886 if(ricSubsDelRsp->protocolIEs.list.array[ieIdx] == NULLP)
7888 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7889 __func__, ieIdx, __LINE__);
7893 if(ieIdx < elementCnt)
7897 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7898 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
7899 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7900 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
7901 ricSubsDelRspIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7902 ricSubsDelRspIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7905 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7906 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7907 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7908 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
7909 ricSubsDelRspIe->value.choice.RANfunctionID = ranFuncId;
7911 /* Prints the Msg formed */
7912 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7913 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7915 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7916 if(encRetVal.encoded == ENCODE_FAIL)
7918 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Response Message (at %s)\n",\
7919 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7924 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Response Message \n");
7925 #ifdef DEBUG_ASN_PRINT
7926 for(int i=0; i< encBufSize; i++)
7928 printf("%x",encBuf[i]);
7933 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7935 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Response Message");
7943 FreeRicSubscriptionDeleteResponse(e2apMsg);
7947 /*******************************************************************
7949 * @brief Free RIC Subscription Delete Request Message
7953 * Function : freeAperDecodingOfRicSubsDeleteReq
7955 * Functionality: Free RIC Subscription Delete Request
7957 * @param E2AP Message PDU
7960 ******************************************************************/
7961 void freeAperDecodingOfRicSubsDeleteReq(E2AP_PDU_t *e2apMsg)
7964 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
7968 if(e2apMsg->choice.initiatingMessage)
7970 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
7971 if(ricSubsDelReq->protocolIEs.list.array)
7973 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
7975 if(ricSubsDelReq->protocolIEs.list.array[ieIdx])
7977 free(ricSubsDelReq->protocolIEs.list.array[ieIdx]);
7980 free(ricSubsDelReq->protocolIEs.list.array);
7986 /*******************************************************************
7988 * @brief Process RIC Subscription delete request
7992 * Function : procRicSubscriptionDeleteRequest
7994 * Functionality: Process RIC subscription delete request.
7995 * Fetch RAN Function and RIC subscription to be deleted.
7996 * Send statistics delete request to MAC for all action sequence
7997 * within this RIC subscription.
7999 * @params[in] E2AP PDU
8002 ******************************************************************/
8003 void procRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
8006 uint16_t ranFuncId = 0;
8007 bool procFailure = false;
8008 RicRequestId ricReqId;
8009 RanFunction *ranFuncDb = NULLP;
8010 CmLList *ricSubsNode = NULLP;
8011 RicSubscription *ricSubsDb = NULLP;
8012 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
8013 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
8015 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Delete Request", __func__);
8020 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
8024 if(!e2apMsg->choice.initiatingMessage)
8026 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
8030 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
8031 if(!ricSubsDelReq->protocolIEs.list.array)
8033 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
8037 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
8039 if(!ricSubsDelReq->protocolIEs.list.array[ieIdx])
8041 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
8045 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
8046 switch(ricSubsDelReqIe->id)
8048 case ProtocolIE_IDE2_id_RICrequestID:
8050 memset(&ricReqId, 0, sizeof(RicRequestId));
8051 ricReqId.requestorId = ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID;
8052 ricReqId.instanceId = ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID;
8056 case ProtocolIE_IDE2_id_RANfunctionID:
8058 ranFuncId = ricSubsDelReqIe->value.choice.RANfunctionID;
8059 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
8062 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
8067 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
8070 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
8071 __func__, ricReqId.requestorId, ricReqId.instanceId);
8076 if(BuildAndSendStatsDeleteReq(ricSubsDb) != ROK)
8078 DU_LOG("\nERROR --> E2AP : Failed to build and send ric subscription delete req to du layers");
8085 } /* End of switch for Protocol IE Id */
8089 } /* End of for loop for Protocol IE list */
8094 freeAperDecodingOfRicSubsDeleteReq(e2apMsg);
8098 /*******************************************************************
8100 * @brief Deallocate the memory allocated for E2 node configuration
8101 * update ack msg by aper decoder
8105 * Function : freeAperDecodingOfE2NodeConfigUpdateAck
8108 * - Deallocate the memory allocated for E2 node configuration
8109 * update ack msg by aper decoder
8111 * @params[in] E2AP_PDU_t *e2apMsg
8112 * @return ROK - success
8115 * ****************************************************************/
8117 void freeAperDecodingOfE2NodeConfigUpdateAck(E2nodeConfigurationUpdateAcknowledge_t *updateAckMsg)
8119 uint8_t arrIdx =0, e2NodeConfigIdx=0;
8120 E2nodeComponentConfigUpdateAck_ItemIEs_t *updateAckItemIe=NULL;
8121 E2nodeComponentConfigUpdateAck_List_t *updateAckList=NULL;
8122 E2nodeComponentConfigRemovalAck_ItemIEs_t *removalAckItemIe=NULL;
8123 E2nodeComponentConfigRemovalAck_List_t *removalAckList=NULL;
8124 E2nodeComponentConfigAdditionAck_ItemIEs_t *additionAckItemIte=NULL;
8125 E2nodeComponentConfigAdditionAck_List_t *additionAckList=NULL;
8127 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULLP;
8128 if(updateAckMsg->protocolIEs.list.array != NULLP)
8130 for(arrIdx = 0; arrIdx < updateAckMsg->protocolIEs.list.count; arrIdx++)
8132 if(updateAckMsg->protocolIEs.list.array[arrIdx])
8134 switch(updateAckMsg->protocolIEs.list.array[arrIdx]->id)
8136 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8138 additionAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8139 if(additionAckList->list.array)
8141 for(e2NodeConfigIdx=0; e2NodeConfigIdx<additionAckList->list.count; e2NodeConfigIdx++)
8143 additionAckItemIte = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) additionAckList->list.array[e2NodeConfigIdx];
8144 if(additionAckItemIte)
8146 switch(additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present)
8148 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8150 f1InterfaceInfo = additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8151 free(f1InterfaceInfo->gNB_DU_ID.buf);
8152 free(f1InterfaceInfo);
8158 free(additionAckItemIte);
8160 free(additionAckList->list.array);
8165 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8167 updateAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8168 if(updateAckList->list.array)
8170 for(e2NodeConfigIdx=0; e2NodeConfigIdx<updateAckList->list.count; e2NodeConfigIdx++)
8172 updateAckItemIe = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) updateAckList->list.array[e2NodeConfigIdx];
8175 switch(updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.present)
8177 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8179 f1InterfaceInfo = updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8180 free(f1InterfaceInfo->gNB_DU_ID.buf);
8181 free(f1InterfaceInfo);
8187 free(updateAckItemIe);
8190 free(updateAckList->list.array);
8194 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8196 removalAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8197 if(removalAckList->list.array)
8199 for(e2NodeConfigIdx=0; e2NodeConfigIdx<removalAckList->list.count; e2NodeConfigIdx++)
8201 removalAckItemIe = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) removalAckList->list.array[e2NodeConfigIdx];
8202 if(removalAckItemIe)
8204 switch(removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.present)
8206 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8208 f1InterfaceInfo = removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8209 free(f1InterfaceInfo->gNB_DU_ID.buf);
8210 free(f1InterfaceInfo);
8216 free(removalAckItemIe);
8219 free(removalAckList->list.array);
8224 free(updateAckMsg->protocolIEs.list.array[arrIdx]);
8227 free(updateAckMsg->protocolIEs.list.array);
8231 /******************************************************************
8233 * @brief Processes the E2 node config update ack msg
8237 * Function :procE2NodeConfigUpdateAck
8239 * Functionality: Processes the E2 node config update ack msg
8241 * @params[in] E2AP_PDU_t ASN decoded E2AP message
8242 * @return ROK - success
8245 * ****************************************************************/
8247 void procE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
8250 uint16_t e2CfgIdx =0;
8251 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck =NULLP;
8252 E2nodeComponentConfigUpdateAck_List_t *e2NodeConfigUpdateAckList=NULLP;
8253 E2nodeComponentConfigUpdateAck_ItemIEs_t *e2NodeUpdateAckItem=NULLP;
8254 E2nodeComponentConfigRemovalAck_List_t *e2NodeConfigRemovalAckList=NULLP;
8255 E2nodeComponentConfigRemovalAck_ItemIEs_t *e2NodeRemovalAckItem=NULLP;
8256 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULLP;
8257 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAdditionAckItem=NULLP;
8259 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
8261 if(e2NodeConfigUpdateAck->protocolIEs.list.array)
8263 for(arrIdx =0; arrIdx<e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
8265 switch(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id)
8267 case ProtocolIE_IDE2_id_TransactionID:
8271 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8273 e2NodeConfigAdditionAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8274 if(e2NodeConfigAdditionAckList->list.array)
8276 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigAdditionAckList->list.count; e2CfgIdx++)
8278 e2NodeAdditionAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2CfgIdx];
8279 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAdditionAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
8280 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
8285 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8287 e2NodeConfigUpdateAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8288 if(e2NodeConfigUpdateAckList->list.array)
8290 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigUpdateAckList->list.count; e2CfgIdx++)
8292 e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[e2CfgIdx];
8293 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeUpdateAckItem->value.choice.E2nodeComponentConfigUpdateAck_Item,\
8294 ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck);
8299 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8301 e2NodeConfigRemovalAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8302 if(e2NodeConfigRemovalAckList->list.array)
8304 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigRemovalAckList->list.count; e2CfgIdx++)
8306 e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[e2CfgIdx];
8307 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeRemovalAckItem->value.choice.E2nodeComponentConfigRemovalAck_Item,\
8308 ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck);
8317 freeAperDecodingOfE2NodeConfigUpdateAck(e2NodeConfigUpdateAck);
8320 /*******************************************************************
8322 * @brief Deallocate the memory allocated for RemovalRequest msg
8326 * Function : FreeRemovalRequest
8329 * - freeing the memory allocated for RemovalRequest
8331 * @params[in] E2AP_PDU_t *e2apMsg
8332 * @return ROK - success
8335 * ****************************************************************/
8336 void FreeRemovalRequest(E2AP_PDU_t *e2apMsg)
8339 E2RemovalRequest_t *removalReq = NULLP;
8341 if(e2apMsg != NULLP)
8343 if(e2apMsg->choice.initiatingMessage != NULLP)
8345 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8346 if(removalReq->protocolIEs.list.array)
8348 for(ieIdx = 0; ieIdx < removalReq->protocolIEs.list.count; ieIdx++)
8350 DU_FREE(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8352 DU_FREE(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8354 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8356 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8360 /*******************************************************************
8362 * @brief Build and send the removal request msg
8366 * Function : BuildAndSendRemovalRequest
8369 * - Buld and send the removal request msg to E2 node
8371 * @return ROK - success
8374 * ****************************************************************/
8376 uint8_t BuildAndSendRemovalRequest()
8378 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
8379 uint8_t ret = RFAILED;
8380 E2AP_PDU_t *e2apMsg = NULLP;
8381 E2RemovalRequest_t *removalReq = NULLP;
8382 asn_enc_rval_t encRetVal; /* Encoder return value */
8384 DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
8388 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8389 if(e2apMsg == NULLP)
8391 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8395 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
8396 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8397 if(e2apMsg->choice.initiatingMessage == NULLP)
8399 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8403 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2removal;
8404 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
8405 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2RemovalRequest;
8406 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8409 removalReq->protocolIEs.list.count = elementCnt;
8410 removalReq->protocolIEs.list.size = elementCnt * sizeof(E2RemovalRequestIEs_t *);
8412 DU_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8413 if(!removalReq->protocolIEs.list.array)
8415 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8419 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
8421 DU_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8422 if(!removalReq->protocolIEs.list.array[ieIdx])
8424 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8429 /* In case of failure */
8430 if(ieIdx < elementCnt)
8434 removalReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8435 removalReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8436 removalReq->protocolIEs.list.array[ieIdx]->value.present = E2RemovalRequestIEs__value_PR_TransactionID;
8437 transId = assignTransactionId();
8438 removalReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8440 /* Prints the Msg formed */
8441 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8443 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8445 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
8447 if(encRetVal.encoded == ENCODE_FAIL)
8449 DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
8450 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8455 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
8456 #ifdef DEBUG_ASN_PRINT
8457 for(int i=0; i< encBufSize; i++)
8459 printf("%x",encBuf[i]);
8463 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8465 DU_LOG("\nERROR --> E2AP : Sending removal request failed");
8471 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
8472 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
8476 /* Free all memory */
8477 FreeRemovalRequest(e2apMsg);
8482 /******************************************************************
8484 * @brief Deallocation of memory allocated by aper decoder
8485 * for Removal failure
8489 * Function : freeAperDecodingOfE2RemovalFailure
8491 * Functionality: Deallocation of memory allocated by aper decoder
8492 * for Removal failure
8494 * @params[in] Pointer to removalFailure
8497 * ****************************************************************/
8498 void freeAperDecodingOfE2RemovalFailure(E2RemovalFailure_t *removalFailure)
8504 if(removalFailure->protocolIEs.list.array)
8506 for(arrIdx=0; arrIdx<removalFailure->protocolIEs.list.count; arrIdx++)
8508 if(removalFailure->protocolIEs.list.array[arrIdx])
8510 free(removalFailure->protocolIEs.list.array[arrIdx]);
8513 free(removalFailure->protocolIEs.list.array);
8518 /******************************************************************
8520 * @brief Processes the E2 removal failure msg
8524 * Function : procE2RemovalFailure
8526 * Functionality: Processes the E2 removal failure msg
8529 * E2AP_PDU_t *e2apMsg
8533 * ****************************************************************/
8534 void ProcE2RemovalFailure(E2AP_PDU_t *e2apMsg)
8536 uint8_t ieIdx = 0, transId=0;
8537 CauseE2_t *cause = NULLP;
8538 E2RemovalFailure_t *e2RemovalFailure=NULLP;
8540 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
8542 if(!e2RemovalFailure->protocolIEs.list.array)
8544 DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
8548 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
8550 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
8552 switch(e2RemovalFailure->protocolIEs.list.array[ieIdx]->id)
8554 case ProtocolIE_IDE2_id_TransactionID:
8556 transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8557 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8558 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8560 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8564 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8568 case ProtocolIE_IDE2_id_CauseE2:
8570 cause = &e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
8571 printE2ErrorCause(cause);
8576 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
8582 freeAperDecodingOfE2RemovalFailure(e2RemovalFailure);
8585 /******************************************************************
8587 * @brief Deallocation of memory allocated by aper decoder
8588 * for Removal failure
8592 * Function : freeAperDecodingOfE2RemovalResponse
8594 * Functionality: Deallocation of memory allocated by aper decoder
8595 * for Removal failure
8597 * @params[in] Pointer to removalResponse
8600 * ****************************************************************/
8601 void freeAperDecodingOfE2RemovalResponse(E2RemovalResponse_t *removalResponse)
8607 if(removalResponse->protocolIEs.list.array)
8609 for(arrIdx=0; arrIdx<removalResponse->protocolIEs.list.count; arrIdx++)
8611 if(removalResponse->protocolIEs.list.array[arrIdx])
8613 free(removalResponse->protocolIEs.list.array[arrIdx]);
8616 free(removalResponse->protocolIEs.list.array);
8621 /*******************************************************************
8623 * @brief process the E2 Removal Response
8627 * Function : ProcE2RemovalResponse
8629 * Functionality: Process E2 Removal Response
8632 * E2AP_PDU_t *e2apMsg
8635 ******************************************************************/
8637 void ProcE2RemovalResponse(E2AP_PDU_t *e2apMsg)
8639 uint8_t ieIdx = 0, transId=0;
8640 E2RemovalResponse_t *removalRsp = NULLP;
8642 removalRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
8644 if(!removalRsp->protocolIEs.list.array)
8646 DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
8650 for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
8652 if(removalRsp->protocolIEs.list.array[ieIdx])
8654 switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
8656 case ProtocolIE_IDE2_id_TransactionID:
8658 transId = removalRsp->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8659 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8660 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8662 DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
8663 cmInetClose(&ricParams.sockFd);
8664 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8665 removeE2NodeInformation();
8669 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8675 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
8682 freeAperDecodingOfE2RemovalResponse(removalRsp);
8685 /*******************************************************************
8687 * @brief Deallocate the memory allocated for E2 Connection Update Failure
8691 * Function : FreeE2ConnectionUpdateFailure
8694 * - freeing the memory allocated for E2ConnectionUpdateFailure
8696 * @params[in] E2AP_PDU_t *e2apMsg
8697 * @return ROK - success
8700 * ****************************************************************/
8701 void FreeE2ConnectionUpdateFailure(E2AP_PDU_t *e2apMsg)
8704 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8706 if(e2apMsg != NULLP)
8708 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
8710 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8711 if(e2ConnectionUpdateFailure->protocolIEs.list.array)
8713 for(ieIdx=0; ieIdx < e2ConnectionUpdateFailure->protocolIEs.list.count; ieIdx++)
8715 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8717 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8719 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8721 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8725 /*******************************************************************
8727 * @brief Buld and send the E2 Connection Update Failure msg
8731 * Function : BuildAndSendE2ConnectionUpdateFailure
8734 * - Buld and send the E2 Connection Update Failure Message
8738 * @return ROK - success
8741 * ****************************************************************/
8743 uint8_t BuildAndSendE2ConnectionUpdateFailure(uint16_t transId, E2FailureCause failureCause)
8745 uint8_t ieIdx = 0, elementCnt = 0;
8746 uint8_t ret = RFAILED;
8747 E2AP_PDU_t *e2apMsg = NULLP;
8748 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8749 asn_enc_rval_t encRetVal; /* Encoder return value */
8751 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Failure Message\n");
8754 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8755 if(e2apMsg == NULLP)
8757 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8760 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
8762 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8763 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
8765 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8769 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
8770 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
8771 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure;
8772 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8775 e2ConnectionUpdateFailure->protocolIEs.list.count = elementCnt;
8776 e2ConnectionUpdateFailure->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateFailure_IEs_t *);
8777 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8778 if(!e2ConnectionUpdateFailure->protocolIEs.list.array)
8780 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8784 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
8786 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8787 if(!e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx])
8789 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8793 if(ieIdx < elementCnt)
8797 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8798 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8799 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_TransactionID;
8800 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8804 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
8805 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
8806 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_CauseE2;
8807 fillE2Cause(&e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, failureCause);
8809 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8811 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8813 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
8814 if(encRetVal.encoded == ENCODE_FAIL)
8816 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update failure structure (at %s)\n",\
8817 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8822 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Failure \n");
8823 for(int i=0; i< encBufSize; i++)
8825 DU_LOG("%x",encBuf[i]);
8830 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8832 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Failure");
8840 FreeE2ConnectionUpdateFailure(e2apMsg);
8844 /*******************************************************************
8846 * @brief fill E2 connection update item
8850 * Function : fillE2connectionUpdateItem
8852 * Functionality: fill E2 connection update item
8855 * E2connectionUpdate Item to be filled
8859 * @return ROK - success
8861 * ****************************************************************/
8863 uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId, uint32_t ipAddress, AssocUsage usage)
8865 CauseE2_t *cause=NULLP;
8866 TNLusage_t *tnlUsage=NULLP;
8867 E2FailureCause failureCause;
8868 TNLinformation_t *tnlInformation = NULLP;
8869 E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
8870 E2connectionSetupFailed_Item_t *connectionRemoveITem=NULLP;
8874 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8876 connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
8877 tnlInformation = &connectionModifyItem->tnlInformation;
8878 tnlUsage = &connectionModifyItem->tnlUsage;
8882 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8884 connectionRemoveITem = (E2connectionSetupFailed_Item_t*)connectionInfo;
8885 tnlInformation= &connectionRemoveITem->tnlInformation;
8886 cause = &connectionRemoveITem->cause;
8893 tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
8894 DU_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
8895 if(!tnlInformation->tnlAddress.buf)
8897 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8901 tnlInformation->tnlAddress.buf[3] = ipAddress & 0xFF;
8902 tnlInformation->tnlAddress.buf[2] = (ipAddress>> 8) & 0xFF;
8903 tnlInformation->tnlAddress.buf[1] = (ipAddress>> 16) & 0xFF;
8904 tnlInformation->tnlAddress.buf[0] = (ipAddress>> 24) & 0xFF;
8905 tnlInformation->tnlAddress.bits_unused = 0;
8909 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8914 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8916 failureCause.causeType = E2_TRANSPORT;
8917 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
8918 fillE2Cause(cause, failureCause);
8928 /*******************************************************************
8930 * @brief Build E2 connection modification list
8934 * Function :BuildE2ConnectionUpdateList
8936 * Functionality: Build E2 connection modification list
8939 * E2 connection update list to be filled
8940 * Count of E2 connection to be added in the list
8941 * Received list of E2 connection
8943 * @return ROK - success
8945 * ****************************************************************/
8947 uint8_t BuildE2ConnectionUpdateList(E2connectionUpdate_List_t *connectionSetupList, uint8_t count, E2ConnectionItem *tmpConnectionList)
8950 E2connectionUpdate_ItemIEs_t *connectionSetupItem=NULLP;
8952 connectionSetupList->list.count = count;
8954 connectionSetupList->list.size = connectionSetupList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
8955 DU_ALLOC(connectionSetupList->list.array, connectionSetupList->list.size);
8956 if(connectionSetupList->list.array)
8958 for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
8960 DU_ALLOC(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
8961 if(connectionSetupList->list.array[arrIdx] == NULLP)
8963 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8966 connectionSetupItem = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
8967 connectionSetupItem->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
8968 connectionSetupItem->criticality= CriticalityE2_ignore;
8969 connectionSetupItem->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
8970 if(fillE2connectionUpdateItem((PTR)&connectionSetupItem->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item,\
8971 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
8973 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
8981 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8987 /*******************************************************************
8989 * @brief Build E2 connection setup failed list
8993 * Function : BuildE2ConnectionSetupFailedList
8995 * Functionality: Build E2 connection setup failed list
8998 * E2 connection setup failed list to be filled
8999 * Count of E2 connection to be added in the list
9000 * Received list of E2 connection
9002 * @return ROK - success
9004 * ****************************************************************/
9006 uint8_t BuildE2ConnectionSetupFailedList(E2connectionSetupFailed_List_t *setupFailedList, uint8_t count, E2ConnectionItem *tmpConnectionList)
9009 E2connectionSetupFailed_ItemIEs_t *setupFailedItem=NULLP;
9011 setupFailedList->list.count = 1;
9013 setupFailedList->list.size = setupFailedList->list.count*sizeof(E2connectionSetupFailed_ItemIEs_t *);
9014 DU_ALLOC(setupFailedList->list.array, setupFailedList->list.size);
9015 if(setupFailedList->list.array)
9017 for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
9019 DU_ALLOC(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9020 if(setupFailedList->list.array[arrIdx] == NULLP)
9022 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9025 setupFailedItem = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
9026 setupFailedItem->id = ProtocolIE_IDE2_id_E2connectionSetupFailed_Item;
9027 setupFailedItem->criticality= CriticalityE2_ignore;
9028 setupFailedItem->value.present = E2connectionSetupFailed_ItemIEs__value_PR_E2connectionSetupFailed_Item;
9029 if(fillE2connectionUpdateItem((PTR)&setupFailedItem->value.choice.E2connectionSetupFailed_Item, ProtocolIE_IDE2_id_E2connectionSetupFailed_Item,\
9030 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
9032 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection failed to update item");
9040 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9046 /*******************************************************************
9048 * @brief Deallocate the memory allocated for E2 Connection
9053 * Function :FreeE2ConnectionUpdateAcknowledge
9056 * - freeing the memory allocated for E2 Connection
9059 * @params[in] E2AP_PDU_t *e2apMsg
9060 * @return ROK - success
9063 * ****************************************************************/
9065 void FreeE2ConnectionUpdateAcknowledge(E2AP_PDU_t *e2apMsg)
9067 uint8_t ieIdx =0, arrIdx=0;
9068 E2connectionUpdateAcknowledge_t *connectionUpdate = NULLP;
9069 E2connectionUpdate_List_t *connectionSetupList = NULLP;
9070 E2connectionSetupFailed_List_t *setupFailedList = NULLP;
9072 if(e2apMsg != NULLP)
9074 if(e2apMsg->choice.successfulOutcome != NULLP)
9076 connectionUpdate = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9077 if(connectionUpdate->protocolIEs.list.array)
9079 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9081 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9083 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9085 case ProtocolIE_IDE2_id_TransactionID:
9088 case ProtocolIE_IDE2_id_E2connectionSetup:
9090 connectionSetupList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9091 if(connectionSetupList->list.array)
9093 for(arrIdx = 0; arrIdx < connectionSetupList->list.count; arrIdx++)
9095 DU_FREE(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
9097 DU_FREE(connectionSetupList->list.array, connectionSetupList->list.size);
9102 case ProtocolIE_IDE2_id_E2connectionSetupFailed:
9104 setupFailedList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
9105 if(setupFailedList->list.array)
9107 for(arrIdx = 0; arrIdx < setupFailedList->list.count; arrIdx++)
9109 DU_FREE(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9111 DU_FREE(setupFailedList->list.array, setupFailedList->list.size);
9116 DU_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9119 DU_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
9121 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9123 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
9127 /*******************************************************************
9129 * @brief Buld and send the E2 Connection Update Acknowledge msg
9133 * Function : BuildAndSendE2ConnectionUpdateAcknowledge
9136 * - Buld and send the E2 Connection Update Acknowledge Message
9139 * List of E2 connection needs to fill in IE
9140 * @return ROK - success
9143 * ****************************************************************/
9145 uint8_t BuildAndSendE2ConnectionUpdateAcknowledge(uint16_t transId, E2ConnectionList connectionInfoList)
9147 uint8_t ieIdx = 0, elementCnt = 0;
9148 uint8_t ret = RFAILED;
9149 E2AP_PDU_t *e2apMsg = NULLP;
9150 asn_enc_rval_t encRetVal;
9151 E2connectionUpdateAcknowledge_t *e2ConnectionUpdateAcknowledge=NULLP;
9153 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Acknowledge Message\n");
9156 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
9157 if(e2apMsg == NULLP)
9159 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9162 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
9164 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9165 if(e2apMsg->choice.successfulOutcome == NULLP)
9167 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9171 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
9172 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
9173 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge;
9174 e2ConnectionUpdateAcknowledge = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9177 if(connectionInfoList.numOfE2ConnectionSetup)
9179 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9182 e2ConnectionUpdateAcknowledge->protocolIEs.list.count = elementCnt;
9183 e2ConnectionUpdateAcknowledge->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateAck_IEs_t*);
9184 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array, e2ConnectionUpdateAcknowledge->protocolIEs.list.size);
9185 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array)
9187 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9191 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
9193 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9194 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx])
9196 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9200 if(ieIdx < elementCnt)
9204 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
9205 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9206 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_TransactionID;
9207 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
9209 if(connectionInfoList.numOfE2ConnectionSetup)
9212 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetup;
9213 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9214 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionUpdate_List;
9215 if(BuildE2ConnectionUpdateList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List, \
9216 connectionInfoList.numOfE2ConnectionSetup, connectionInfoList.setupE2Connection) != ROK)
9218 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection setup list");
9223 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9226 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetupFailed;
9227 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9228 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionSetupFailed_List;
9229 if(BuildE2ConnectionSetupFailedList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List, \
9230 connectionInfoList.numOfE2ConnectionFailedToSetup, connectionInfoList.failedToSetupE2Connection) != ROK)
9232 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection failed to setup list");
9237 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
9239 memset(encBuf, 0, ENC_BUF_MAX_LEN);
9241 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
9242 if(encRetVal.encoded == ENCODE_FAIL)
9244 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update acknowledge failure structure (at %s)\n",\
9245 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9250 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Acknowledge \n");
9251 for(int i=0; i< encBufSize; i++)
9253 DU_LOG("%x",encBuf[i]);
9258 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
9260 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Acknowledge");
9268 FreeE2ConnectionUpdateAcknowledge(e2apMsg);
9272 /******************************************************************
9274 * @brief Deallocation of memory allocated by aper decoder for
9275 * E2 Connection Update
9279 * Function :freeAperDecodingOfE2ConnectionUpdate
9281 * Functionality: Deallocation of memory allocated by aper decoder for
9282 * E2 Connection Update
9284 * @params[in] Pointer to connectionUpdate
9287 * ****************************************************************/
9289 void freeAperDecodingOfE2ConnectionUpdate(E2connectionUpdate_t *connectionUpdate)
9291 uint8_t ieIdx =0, arrIdx=0;
9292 E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
9293 E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
9295 if(connectionUpdate->protocolIEs.list.array)
9297 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9299 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9301 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9303 case ProtocolIE_IDE2_id_TransactionID:
9306 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9308 connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9309 if(connectionToBeModifyList->list.array)
9311 for(arrIdx= 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
9313 free(connectionToBeModifyList->list.array[arrIdx]);
9315 free(connectionToBeModifyList->list.array);
9319 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9321 connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
9322 if(connectionToBeRemoveList->list.array)
9324 for(arrIdx= 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
9326 free(connectionToBeRemoveList->list.array[arrIdx]);
9328 free(connectionToBeRemoveList->list.array);
9333 free(connectionUpdate->protocolIEs.list.array[ieIdx]);
9336 free(connectionUpdate->protocolIEs.list.array);
9340 /*******************************************************************
9342 * @brief Handling of E2 connection modification Ie
9346 * Function : handleE2ConnectionModification
9348 * Functionality: Handling of E2 connection modification Ie
9351 * E2 Connection update list
9352 * E2 connection list which needs to be filled
9355 ******************************************************************/
9357 void handleE2ConnectionModification(E2connectionUpdate_List_t *connectionUpdateList, E2ConnectionList *connectionInfoList)
9359 uint32_t ipAddress=0;
9360 bool infoFound = false;
9361 uint8_t arrIdx=0,idx=0, count =0;
9362 E2connectionUpdate_ItemIEs_t *connectionModifyItem=NULLP;
9364 if(connectionUpdateList->list.array)
9366 for(arrIdx = 0; arrIdx < connectionUpdateList->list.count; arrIdx++)
9368 connectionModifyItem= (E2connectionUpdate_ItemIEs_t*)connectionUpdateList->list.array[arrIdx];
9369 bitStringToInt(&connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlInformation.tnlAddress, &ipAddress);
9370 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9372 /* If the TNL information is found in the data base, update the
9373 * information in the database */
9374 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9376 duCb.e2apDb.tnlAssoc[idx].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9382 /* If the TNL information is found in the data base, then add the
9383 * information in setupE2Connection array else add in failedToSetupE2Connection array */
9384 if(infoFound == true)
9386 count =connectionInfoList->numOfE2ConnectionSetup;
9387 connectionInfoList->setupE2Connection[count].ipV4Addr = duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr;
9388 connectionInfoList->setupE2Connection[count].usage = duCb.e2apDb.tnlAssoc[idx].usage;
9389 connectionInfoList->numOfE2ConnectionSetup++;
9393 count = connectionInfoList->numOfE2ConnectionFailedToSetup;
9394 connectionInfoList->failedToSetupE2Connection[count].ipV4Addr = ipAddress;
9395 connectionInfoList->failedToSetupE2Connection[count].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9396 connectionInfoList->numOfE2ConnectionFailedToSetup++;
9403 /*******************************************************************
9405 * @brief Handling of E2 connection removal Ie
9409 * Function : handleE2ConnectionRemoval
9411 * Functionality: Handling of E2 connection removal Ie
9414 * E2 Connection removal List
9417 ******************************************************************/
9419 void handleE2ConnectionRemoval(E2connectionUpdateRemove_List_t *connectionRemovalList)
9421 uint32_t ipAddress=0;
9422 uint8_t arrIdx=0,idx=0;
9423 E2connectionUpdateRemove_ItemIEs_t *connectionRemovalItem=NULLP;
9425 if(connectionRemovalList->list.array)
9427 for(arrIdx = 0; arrIdx < connectionRemovalList->list.count; arrIdx++)
9429 connectionRemovalItem= (E2connectionUpdateRemove_ItemIEs_t*)connectionRemovalList->list.array[arrIdx];
9430 bitStringToInt(&connectionRemovalItem->value.choice.E2connectionUpdateRemove_Item.tnlInformation.tnlAddress, &ipAddress);
9431 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9433 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9435 cmInetClose(&ricParams.sockFd);
9436 removeE2NodeInformation();
9445 /*******************************************************************
9447 * @brief Process e2 connection update received from RIC
9451 * Function : procE2ConnectionUpdate
9453 * Functionality: Process e2 connection update received from RIC
9455 * @param E2AP_PDU_t *e2apMsg
9458 ******************************************************************/
9460 void procE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
9462 uint8_t arrIdx =0, transId =0;
9463 bool invalidTransId = false, connectionFailedToUpdate=false;
9464 E2FailureCause failureCause;
9465 E2ConnectionList connectionInfoList;
9466 E2connectionUpdate_t *connectionUpdate=NULLP;
9468 DU_LOG("\nINFO --> E2AP : E2 connection update received");
9469 connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
9471 memset(&connectionInfoList, 0, sizeof(E2ConnectionList));
9472 for(arrIdx=0; arrIdx<connectionUpdate->protocolIEs.list.count; arrIdx++)
9474 switch(connectionUpdate->protocolIEs.list.array[arrIdx]->id)
9476 case ProtocolIE_IDE2_id_TransactionID:
9478 transId = connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
9481 failureCause.causeType = E2_PROTOCOL;
9482 failureCause.cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
9483 invalidTransId = true;
9488 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9490 handleE2ConnectionModification(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdate_List,\
9491 &connectionInfoList);
9492 if((connectionInfoList.numOfE2ConnectionSetup == 0) && (connectionInfoList.numOfE2ConnectionFailedToSetup > 0))
9494 failureCause.causeType = E2_TRANSPORT;
9495 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
9496 connectionFailedToUpdate =true;
9502 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9504 handleE2ConnectionRemoval(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdateRemove_List);
9510 DU_LOG("\nERROR --> E2AP : Invalid IE received[%ld]",connectionUpdate->protocolIEs.list.array[arrIdx]->id);
9515 if(invalidTransId == true || connectionFailedToUpdate ==true)
9519 if(invalidTransId == true || connectionFailedToUpdate == true)
9521 if(BuildAndSendE2ConnectionUpdateFailure(transId, failureCause) != ROK)
9523 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update failure");
9528 if(BuildAndSendE2ConnectionUpdateAcknowledge(transId, connectionInfoList) != ROK)
9530 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update ack");
9534 freeAperDecodingOfE2ConnectionUpdate(connectionUpdate);
9537 /*******************************************************************
9539 * @brief Free RIC Subscription action to be added list
9543 * Function : freeAperDecodingOfRicSubsActionToBeAdded
9545 * Functionality: Free the RIC Subscription action to be added list
9547 * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
9550 * ****************************************************************/
9551 void freeAperDecodingOfRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
9553 uint8_t elementIdx = 0;
9554 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
9556 if(subsDetails->list.array)
9558 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9560 if(subsDetails->list.array[elementIdx])
9562 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
9563 free(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf);
9564 free(subsDetails->list.array[elementIdx]);
9567 free(subsDetails->list.array);
9571 /*******************************************************************
9573 * @brief Deallocation of memory allocated by aper decoder for
9574 * RIC Subscription action to be removed list
9578 * Function : freeAperDecodingOfRicSubsActionToBeRemoved
9580 * Functionality: Free the RIC Subscription action to be removed list
9582 * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
9585 * ****************************************************************/
9586 void freeAperDecodingOfRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
9588 uint8_t elementIdx = 0;
9590 if(subsDetails->list.array)
9592 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9594 if(subsDetails->list.array[elementIdx])
9596 free(subsDetails->list.array[elementIdx]);
9599 free(subsDetails->list.array);
9603 /*******************************************************************
9605 * @brief Deallocation of memory allocated by aper decoder for
9606 * RIC Subscription action to be modify
9610 * Function : freeAperDecodingOfRicSubsActionToBeModified
9612 * Functionality: Free the RIC Subscription action to be modify
9614 * @params[in] RICactions_ToBeModifiedForModification_List_t List
9617 * ****************************************************************/
9618 void freeAperDecodingOfRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
9620 uint8_t elementIdx = 0;
9621 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
9623 if(subsDetails->list.array)
9625 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9627 if(subsDetails->list.array[elementIdx])
9629 actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx];
9630 if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
9632 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf);
9633 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition);
9635 free(subsDetails->list.array[elementIdx]);
9638 free(subsDetails->list.array);
9642 /*******************************************************************
9644 * @brief Deallocation of memory allocated by aper decoder for
9645 * RIC Subscription modification Request
9649 * Function freeAperDecodingOfRicSubsModificationReq
9651 * Functionality : Free RIC Subscription modification Request
9653 * @params[in] E2AP_PDU
9656 ******************************************************************/
9657 void freeAperDecodingOfRicSubsModificationReq(E2AP_PDU_t *e2apRicMsg)
9660 RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
9661 RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe;
9663 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
9665 if(ricSubscriptionModReq->protocolIEs.list.array)
9667 for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
9669 if(ricSubscriptionModReq->protocolIEs.list.array[idx])
9671 ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
9673 switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
9675 case ProtocolIE_IDE2_id_RICrequestID:
9678 case ProtocolIE_IDE2_id_RANfunctionID:
9681 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
9683 freeAperDecodingOfRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
9686 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
9688 freeAperDecodingOfRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
9691 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
9693 freeAperDecodingOfRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
9698 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
9704 free(ricSubscriptionModReq->protocolIEs.list.array[idx]);
9707 free(ricSubscriptionModReq->protocolIEs.list.array);
9711 /*******************************************************************
9713 * @brief Process RIC Subscription modification request
9717 * Function : procRicSubscriptionModificationRequest
9719 * Functionality: Process RIC subscription modification request.
9721 * @params[in] E2AP PDU
9724 ******************************************************************/
9725 void procRicSubscriptionModificationRequest(E2AP_PDU_t *e2apMsg)
9728 uint16_t ranFuncId = 0;
9729 bool procFailure = false;
9730 RicRequestId ricReqId;
9731 RanFunction *ranFuncDb = NULLP;
9732 CmLList *ricSubsNode = NULLP;
9733 RicSubscription *ricSubsDb = NULLP;
9734 RICsubscriptionModificationRequest_t *ricSubsModifyReq = NULLP;
9735 RICsubscriptionModificationRequest_IEs_t *ricSubsModifyReqIe = NULLP;
9737 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Request", __func__);
9742 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
9746 if(!e2apMsg->choice.initiatingMessage)
9748 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
9752 ricSubsModifyReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
9753 for(ieIdx = 0; ieIdx < ricSubsModifyReq->protocolIEs.list.count; ieIdx++)
9755 if(!ricSubsModifyReq->protocolIEs.list.array[ieIdx])
9757 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
9761 ricSubsModifyReqIe = ricSubsModifyReq->protocolIEs.list.array[ieIdx];
9762 switch(ricSubsModifyReqIe->id)
9764 case ProtocolIE_IDE2_id_RICrequestID:
9766 memset(&ricReqId, 0, sizeof(RicRequestId));
9767 ricReqId.requestorId = ricSubsModifyReqIe->value.choice.RICrequestID.ricRequestorID;
9768 ricReqId.instanceId = ricSubsModifyReqIe->value.choice.RICrequestID.ricInstanceID;
9772 case ProtocolIE_IDE2_id_RANfunctionID:
9774 ranFuncId = ricSubsModifyReqIe->value.choice.RANfunctionID;
9775 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
9778 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
9783 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
9786 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
9787 __func__, ricReqId.requestorId, ricReqId.instanceId);
9797 } /* End of switch for Protocol IE Id */
9801 } /* End of for loop for Protocol IE list */
9806 freeAperDecodingOfRicSubsModificationReq(e2apMsg);
9809 /*******************************************************************
9810 * @brief Free RIC Subscription Modification Failure Message
9814 * Function : FreeRicSubscriptionModificationFailure
9816 * Functionality: Free RIC Subscription Modification Failure
9818 * @param E2AP Message PDU
9821 ******************************************************************/
9822 void FreeRicSubscriptionModificationFailure(E2AP_PDU_t *e2apMsg)
9825 RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
9829 if(e2apMsg->choice.unsuccessfulOutcome)
9831 ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
9832 if(ricSubsModFailure->protocolIEs.list.array)
9834 for(ieIdx = 0; ieIdx < ricSubsModFailure->protocolIEs.list.count; ieIdx++)
9836 DU_FREE(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
9838 DU_FREE(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
9840 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
9842 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
9845 /*******************************************************************
9847 * @brief Builds and Send RIC Subscription Modification Failure
9851 * Function : BuildAndSendRicSubscriptionModificationFailure
9853 * Functionality: Build and send RIC Subscription Modification Failure.
9859 * @return ROK - success
9862 ******************************************************************/
9863 uint8_t BuildAndSendRicSubscriptionModificationFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
9865 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
9866 E2AP_PDU_t *e2apMsg = NULLP;
9867 RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
9868 RICsubscriptionModificationFailure_IEs_t *ricSubsModFailureIe = NULLP;
9869 asn_enc_rval_t encRetVal; /* Encoder return value */
9873 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Failure Message\n");
9875 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
9876 if(e2apMsg == NULLP)
9878 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
9882 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
9883 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
9884 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
9886 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
9889 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
9890 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
9891 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure;
9894 ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
9897 ricSubsModFailure->protocolIEs.list.count = elementCnt;
9898 ricSubsModFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationFailure_IEs_t *);
9900 DU_ALLOC(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
9901 if(ricSubsModFailure->protocolIEs.list.array == NULLP)
9903 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
9907 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
9909 DU_ALLOC(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
9910 if(ricSubsModFailure->protocolIEs.list.array[ieIdx] == NULLP)
9912 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
9913 __func__, ieIdx, __LINE__);
9917 if(ieIdx < elementCnt)
9921 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
9922 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
9923 ricSubsModFailureIe->criticality = CriticalityE2_reject;
9924 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RICrequestID;
9925 ricSubsModFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
9926 ricSubsModFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
9929 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
9930 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
9931 ricSubsModFailureIe->criticality = CriticalityE2_reject;
9932 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RANfunctionID;
9933 ricSubsModFailureIe->value.choice.RANfunctionID = ranFuncId;
9936 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
9937 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
9938 ricSubsModFailureIe->criticality = CriticalityE2_reject;
9939 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_CauseE2;
9940 fillE2Cause(&ricSubsModFailureIe->value.choice.CauseE2, failureCause);
9942 /* Prints the Msg formed */
9943 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
9944 memset(encBuf, 0, ENC_BUF_MAX_LEN);
9946 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
9947 if(encRetVal.encoded == ENCODE_FAIL)
9949 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Failure Message (at %s)\n",\
9950 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9955 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Failure Message \n");
9956 #ifdef DEBUG_ASN_PRINT
9957 for(int i=0; i< encBufSize; i++)
9959 printf("%x",encBuf[i]);
9964 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
9966 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Failure Message");
9974 FreeRicSubscriptionModificationFailure(e2apMsg);
9978 /*******************************************************************
9980 * @brief Handles received E2AP message and sends back response
9984 * Function : E2APMsgHdlr
9987 * - Decodes received E2AP control message
9988 * - Prepares response message, encodes and sends to SCTP
9991 * @return ROK - success
9994 * ****************************************************************/
9995 void E2APMsgHdlr(Buffer *mBuf)
9998 char *recvBuf = NULLP;
10000 MsgLen recvBufLen =0;
10001 E2AP_PDU_t *e2apMsg = NULLP;
10002 asn_dec_rval_t rval ={0}; /* Decoder return value */
10003 E2AP_PDU_t e2apasnmsg={0} ;
10005 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
10006 ODU_PRINT_MSG(mBuf, 0,0);
10008 /* Copy mBuf into char array to decode it */
10009 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
10010 DU_ALLOC(recvBuf, (Size)recvBufLen);
10012 if(recvBuf == NULLP)
10014 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
10017 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
10019 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
10023 #ifdef DEBUG_ASN_PRINT
10024 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
10025 for(i=0; i< recvBufLen; i++)
10027 printf("%x",recvBuf[i]);
10031 /* Decoding flat buffer into E2AP messsage */
10032 e2apMsg = &e2apasnmsg;
10033 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
10035 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
10036 DU_FREE(recvBuf, (Size)recvBufLen);
10038 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10040 DU_LOG("\nERROR --> E2AP : ASN decode failed");
10044 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
10046 switch(e2apMsg->present)
10048 case E2AP_PDU_PR_unsuccessfulOutcome:
10050 switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
10052 case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
10054 procE2SetupFailure(e2apMsg);
10057 case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure:
10059 procE2NodeConfigUpdateFailure(e2apMsg);
10062 case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure:
10064 procRicServiceUpdateFailure(e2apMsg);
10067 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse:
10069 procRicSubscriptionModificationRefuse(e2apMsg);
10072 case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
10074 ProcE2RemovalFailure(e2apMsg);
10079 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
10080 e2apMsg->choice.unsuccessfulOutcome->value.present);
10084 free(e2apMsg->choice.unsuccessfulOutcome);
10087 case E2AP_PDU_PR_successfulOutcome:
10089 switch(e2apMsg->choice.successfulOutcome->value.present)
10091 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
10095 procE2SetupRsp(e2apMsg);
10099 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
10101 procResetResponse(e2apMsg);
10104 case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge:
10106 procRicServiceUpdateAck(e2apMsg);
10109 case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm:
10111 procRicSubscriptionModificationConfirm(e2apMsg);
10114 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
10116 procE2NodeConfigUpdateAck(e2apMsg);
10119 case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
10121 ProcE2RemovalResponse(e2apMsg);
10126 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
10127 e2apMsg->choice.successfulOutcome->value.present);
10130 }/* End of switch(successfulOutcome) */
10131 free(e2apMsg->choice.successfulOutcome);
10135 case E2AP_PDU_PR_initiatingMessage:
10137 switch(e2apMsg->choice.initiatingMessage->value.present)
10139 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
10141 procRicSubscriptionRequest(e2apMsg);
10144 case InitiatingMessageE2__value_PR_RICserviceQuery:
10146 procRicServiceQuery(e2apMsg);
10149 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
10151 DU_LOG("\nINFO --> E2AP : Error indication received");
10154 case InitiatingMessageE2__value_PR_ResetRequestE2:
10156 DU_LOG("\nINFO --> E2AP : Reset request received");
10157 procE2ResetRequest(e2apMsg);
10160 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest:
10162 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Request received");
10163 procRicSubscriptionDeleteRequest(e2apMsg);
10166 case InitiatingMessageE2__value_PR_E2RemovalRequest:
10168 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
10169 procE2RemovalRequest(e2apMsg);
10172 case InitiatingMessageE2__value_PR_E2connectionUpdate:
10174 DU_LOG("\nINFO --> E2AP : E2 coneection update received");
10175 procE2ConnectionUpdate(e2apMsg);
10178 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest:
10180 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Request received");
10181 procRicSubscriptionModificationRequest(e2apMsg);
10186 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
10187 e2apMsg->choice.initiatingMessage->value.present);
10190 }/* End of switch(initiatingMessage) */
10191 free(e2apMsg->choice.initiatingMessage);
10196 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
10201 }/* End of switch(e2apMsg->present) */
10203 } /* End of E2APMsgHdlr */
10205 /**********************************************************************
10207 **********************************************************************/