1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
18 #include "common_def.h"
24 #include "du_app_mac_inf.h"
25 #include "du_app_rlc_inf.h"
26 #include "du_e2ap_mgr.h"
27 #include "du_e2ap_msg_hdl.h"
31 #include "du_mgr_main.h"
32 #include "du_msg_hdl.h"
34 #include "GlobalE2node-gNB-ID.h"
35 #include "ProtocolIE-FieldE2.h"
36 #include "E2setupRequest.h"
37 #include "InitiatingMessageE2.h"
38 #include "SuccessfulOutcomeE2.h"
39 #include "UnsuccessfulOutcomeE2.h"
41 #include "odu_common_codec.h"
42 #include "E2nodeComponentInterfaceF1.h"
43 #include "E2setupRequest.h"
44 #include "du_e2_conversions.h"
45 #include "E2SM-KPM-RANfunction-Description.h"
46 #include "RANfunction-Name.h"
47 #include "RIC-EventTriggerStyle-Item.h"
48 #include "RIC-ReportStyle-Item.h"
49 #include "MeasurementInfo-Action-Item.h"
50 #include "E2SM-KPM-EventTriggerDefinition.h"
51 #include "E2SM-KPM-EventTriggerDefinition-Format1.h"
52 #include "E2SM-KPM-ActionDefinition.h"
53 #include "E2SM-KPM-ActionDefinition-Format1.h"
54 #include "MeasurementInfoItem.h"
55 #include "RANfunctionsIDcause-List.h"
56 #include "MeasurementRecord.h"
57 #include "MeasurementData.h"
58 #include "MeasurementRecordItem.h"
59 #include "MeasurementDataItem.h"
60 #include "E2SM-KPM-IndicationMessage-Format1.h"
61 #include "E2SM-KPM-IndicationMessage.h"
62 #include "E2SM-KPM-IndicationHeader.h"
63 #include "E2SM-KPM-IndicationHeader-Format1.h"
64 #include "LabelInfoItem.h"
66 /*******************************************************************
68 * @brief Fill E2 Failure Cause
72 * Function : fillE2Cause
74 * Functionality: Fill E2 Failure Cause
76 * @params[in] E2 Cause pointer to be filled in
77 * E2 Cause to be filled from
80 ******************************************************************/
81 void fillE2Cause(CauseE2_t *e2Cause, E2FailureCause failureCause)
83 e2Cause->present = failureCause.causeType;
84 switch(e2Cause->present)
86 case CauseE2_PR_ricRequest:
88 e2Cause->choice.ricRequest = failureCause.cause;
91 case CauseE2_PR_ricService:
93 e2Cause->choice.ricService = failureCause.cause;
96 case CauseE2_PR_e2Node:
98 e2Cause->choice.e2Node = failureCause.cause;
101 case CauseE2_PR_transport:
103 e2Cause->choice.transport = failureCause.cause;
106 case CauseE2_PR_protocol:
108 e2Cause->choice.protocol = failureCause.cause;
111 case CauseE2_PR_misc:
113 e2Cause->choice.misc = failureCause.cause;
116 case CauseE2_PR_NOTHING:
122 /*******************************************************************
124 * @brief Printing Type and Cause of failure
128 * Function : printE2ErrorCause
130 * Functionality: Printing Type and Cause of failure
132 * @params[in] E2 Cause
135 ******************************************************************/
136 void printE2ErrorCause(CauseE2_t *cause)
138 switch(cause->present)
140 case CauseE2_PR_ricRequest:
142 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Request", cause->choice.ricRequest);
145 case CauseE2_PR_ricService:
147 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Service", cause->choice.ricService);
150 case CauseE2_PR_e2Node:
152 DU_LOG("Failure_Type [%s] Cause [%ld]", "E2_Node", cause->choice.e2Node);
155 case CauseE2_PR_transport:
157 DU_LOG("Failure_Type [%s] Cause [%ld]", "Transport", cause->choice.transport);
160 case CauseE2_PR_protocol:
162 DU_LOG("Failure_Type [%s] Cause [%ld]", "Protocol", cause->choice.protocol);
165 case CauseE2_PR_misc:
167 DU_LOG("Failure_Type [%s] Cause [%ld]", "Miscellaneous", cause->choice.misc);
172 DU_LOG("Failure_Type and Cause unknown");
178 /*******************************************************************
180 * @brief Deallocate the memory allocated for E2 Removal Failure
184 * Function : FreeE2RemovalFailure
187 * - freeing the memory allocated for E2RemovalFailure
189 * @params[in] E2AP_PDU_t *e2apMsg
190 * @return ROK - success
193 * ****************************************************************/
194 void FreeE2RemovalFailure(E2AP_PDU_t *e2apMsg)
197 E2RemovalFailure_t *e2RemovalFailure=NULLP;
201 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
203 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
204 if(e2RemovalFailure->protocolIEs.list.array)
206 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
208 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
210 DU_FREE(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
213 DU_FREE(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
215 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
217 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
221 /*******************************************************************
223 * @brief Buld and send the E2 Removal Failure msg
227 * Function : BuildAndSendE2RemovalFailure
230 * - Buld and send the E2 Removal Failure Message
231 * @params[in] Trans Id
232 * @return ROK - success
235 * ****************************************************************/
237 uint8_t BuildAndSendRemovalFailure(uint16_t transId, E2FailureCause failureCause)
239 uint8_t ieIdx = 0, elementCnt = 0;
240 uint8_t ret = RFAILED;
241 E2AP_PDU_t *e2apMsg = NULLP;
242 E2RemovalFailure_t *e2RemovalFailure=NULLP;
243 asn_enc_rval_t encRetVal; /* Encoder return value */
245 DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
248 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
251 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
254 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
256 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
257 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
259 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
263 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
264 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
265 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure;
266 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
269 e2RemovalFailure->protocolIEs.list.count = elementCnt;
270 e2RemovalFailure->protocolIEs.list.size = elementCnt * sizeof(E2RemovalFailureIEs_t *);
271 DU_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
272 if(!e2RemovalFailure->protocolIEs.list.array)
274 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
278 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
280 DU_ALLOC(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
281 if(!e2RemovalFailure->protocolIEs.list.array[ieIdx])
283 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
287 if(ieIdx < elementCnt)
291 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
292 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
293 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = E2RemovalFailureIEs__value_PR_TransactionID;
294 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
298 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
299 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
300 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
301 fillE2Cause(&e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, failureCause);
303 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
305 memset(encBuf, 0, ENC_BUF_MAX_LEN);
307 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
308 if(encRetVal.encoded == ENCODE_FAIL)
310 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
311 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
316 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
317 for(int i=0; i< encBufSize; i++)
319 DU_LOG("%x",encBuf[i]);
324 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
326 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Failure");
334 FreeE2RemovalFailure(e2apMsg);
338 /*******************************************************************
340 * @brief Deallocate the memory allocated for E2 Removal Response
344 * Function : FreeE2RemovalResponse
347 * - freeing the memory allocated for E2RemovalResponse
349 * @params[in] E2AP_PDU_t *e2apMsg
350 * @return ROK - success
353 * ****************************************************************/
354 void FreeE2RemovalResponse(E2AP_PDU_t *e2apMsg)
357 E2RemovalResponse_t *e2RemovalResponse=NULLP;
361 if(e2apMsg->choice.successfulOutcome != NULLP)
363 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
364 if(e2RemovalResponse->protocolIEs.list.array)
366 for(ieIdx=0; ieIdx < e2RemovalResponse->protocolIEs.list.count; ieIdx++)
368 if(e2RemovalResponse->protocolIEs.list.array[ieIdx])
370 DU_FREE(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
373 DU_FREE(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
375 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
377 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
381 /*******************************************************************
383 * @brief Buld and send the E2 Removal Response msg
387 * Function : BuildAndSendE2RemovalResponse
390 * - Buld and send the E2 Removal Response Message
391 * @params[in] Trans Id
392 * @return ROK - success
395 * ****************************************************************/
396 uint8_t BuildAndSendRemovalResponse(uint16_t transId)
398 uint8_t ieIdx = 0, elementCnt = 0;
399 uint8_t ret = RFAILED;
400 E2AP_PDU_t *e2apMsg = NULLP;
401 E2RemovalResponse_t *e2RemovalResponse=NULLP;
402 asn_enc_rval_t encRetVal; /* Encoder return value */
404 DU_LOG("\nINFO --> E2AP : Building E2 Removal Response Message\n");
407 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
410 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
413 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
415 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
416 if(e2apMsg->choice.successfulOutcome == NULLP)
418 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
422 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
423 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
424 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2RemovalResponse;
425 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
428 e2RemovalResponse->protocolIEs.list.count = elementCnt;
429 e2RemovalResponse->protocolIEs.list.size = elementCnt * sizeof(E2RemovalResponseIEs_t *);
430 DU_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
431 if(!e2RemovalResponse->protocolIEs.list.array)
433 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
437 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
439 DU_ALLOC(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
440 if(!e2RemovalResponse->protocolIEs.list.array[ieIdx])
442 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
446 if(ieIdx < elementCnt)
450 e2RemovalResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
451 e2RemovalResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
452 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.present = E2RemovalResponseIEs__value_PR_TransactionID;
453 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
455 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
457 memset(encBuf, 0, ENC_BUF_MAX_LEN);
459 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
460 if(encRetVal.encoded == ENCODE_FAIL)
462 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
463 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
468 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
469 for(int i=0; i< encBufSize; i++)
471 DU_LOG("%x",encBuf[i]);
476 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
478 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Response");
486 FreeE2RemovalResponse(e2apMsg);
490 /******************************************************************
492 * @brief Deallocation of memory allocated by aper decoder for Removal req
496 * Function : freeAperDecodingOfE2RemovalReq
498 * Functionality: Deallocation of memory allocated by aper decoder for
501 * @params[in] Pointer to removalReq
504 * ****************************************************************/
505 void freeAperDecodingOfE2RemovalReq(E2RemovalRequest_t *removalReq)
511 if(removalReq->protocolIEs.list.array)
513 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
515 if(removalReq->protocolIEs.list.array[arrIdx])
517 free(removalReq->protocolIEs.list.array[arrIdx]);
520 free(removalReq->protocolIEs.list.array);
525 /*******************************************************************
527 * @brief Process Removal req received from RIC
531 * Function : procE2RemovalRequest
533 * Functionality: Process Removal req received from RIC
535 * @param E2AP_PDU_t *e2apMsg
538 ******************************************************************/
540 void procE2RemovalRequest(E2AP_PDU_t *e2apMsg)
544 E2FailureCause failureCause;
545 E2RemovalRequest_t *removalReq=NULLP;
547 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
548 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
550 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
552 switch(removalReq->protocolIEs.list.array[arrIdx]->id)
554 case ProtocolIE_IDE2_id_TransactionID:
556 transId = removalReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
561 DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
567 if(transId>=0 && transId<=255)
569 if(BuildAndSendRemovalResponse(transId) != ROK)
571 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
576 failureCause.causeType = E2_PROTOCOL;
577 failureCause.cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
579 if(BuildAndSendRemovalFailure(transId, failureCause) != ROK)
581 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
584 freeAperDecodingOfE2RemovalReq(removalReq);
587 /*******************************************************************
589 * @brief Free the ErrorIndication Message
593 * Function : FreeRicIndication
595 * Functionality: Free the ErrorIndication Message
598 * E2AP_PDU is to freed
601 ******************************************************************/
602 void FreeErrorIndication(E2AP_PDU_t *e2apMsg)
605 ErrorIndicationE2_t *errorIndicationMsg= NULLP;
609 if(e2apMsg->choice.initiatingMessage != NULLP)
611 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
612 if(errorIndicationMsg!= NULLP)
614 if(errorIndicationMsg->protocolIEs.list.array != NULLP)
616 for(arrIdx=0; arrIdx<errorIndicationMsg->protocolIEs.list.count; arrIdx++)
618 DU_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t));
620 DU_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size);
623 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
625 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
629 /*******************************************************************
631 * @brief Builds and Send the ErrorIndication Message
635 * Function : BuildAndSendErrorIndication
637 * Functionality:Fills the ErrorIndication Message
644 * @return ROK - success
647 ******************************************************************/
649 uint8_t BuildAndSendErrorIndication(int8_t transId, RicRequestId requestId, uint16_t ranFuncId, E2FailureCause failureCause)
651 uint8_t elementCnt =0, arrIdx=0, ret = RFAILED;
652 E2AP_PDU_t *e2apMsg = NULLP;
653 ErrorIndicationE2_t *errorIndicationMsg=NULLP;
654 asn_enc_rval_t encRetVal; /* Encoder return value */
658 DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
660 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
663 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
667 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
668 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
669 if(e2apMsg->choice.initiatingMessage == NULLP)
671 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
674 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
675 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
676 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2;
678 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
680 /* Element count is 2 for TransactionID/RICrequestID and Cause.
681 * If the RAN function id is present, the count will be increased.*/
688 errorIndicationMsg->protocolIEs.list.count = elementCnt;
689 errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*);
691 /* Initialize the E2Setup members */
692 DU_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
693 if(errorIndicationMsg->protocolIEs.list.array == NULLP)
695 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
699 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
701 DU_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
702 if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
704 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array [%d] elements in %s at line %d", arrIdx, __func__, __LINE__);
708 if(arrIdx < elementCnt)
713 if(transId >=0 && transId<=255)
716 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
717 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
718 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID;
719 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
724 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID;
725 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
726 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID;
727 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId;
728 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
733 /* RAN Function ID */
735 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID;
736 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
737 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID;
738 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId;
743 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
744 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
745 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
746 fillE2Cause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, failureCause);
748 /* Prints the Msg formed */
749 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
750 memset(encBuf, 0, ENC_BUF_MAX_LEN);
752 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
754 if(encRetVal.encoded == ENCODE_FAIL)
756 DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
757 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
762 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
763 #ifdef DEBUG_ASN_PRINT
764 for(int i=0; i< encBufSize; i++)
766 printf("%x",encBuf[i]);
771 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
773 DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
779 FreeErrorIndication(e2apMsg);
783 /******************************************************************
785 * @brief Deallocation of memory allocated by aper decoder for e2
786 * Config Update Failure
790 * Function : freeAperDecodingOfE2Node Config UpdateFailure
792 * Functionality: Deallocation of memory allocated by aper decoder
793 * for e2 Config Update Failure
795 * @params[in] E2nodeConfigurationUpdateFailure_t to be deallocated
798 * ****************************************************************/
800 void freeAperDecodingOfE2NodeConfigUpdateFailure(E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail)
806 if(e2NodeCfgUpdFail->protocolIEs.list.array)
808 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
810 if(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx])
812 free(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]);
815 free(e2NodeCfgUpdFail->protocolIEs.list.array);
820 /******************************************************************
822 * @brief Processes E2 Node Config Update Failure sent by RIC
826 * Function : procE2NodeConfigUpdateFailure
828 * Functionality: Processes E2 Node Config Update failure sent by RIC
830 * @params[in] E2AP_PDU_t ASN decoded E2AP message
831 * @return ROK - success
834 * ****************************************************************/
836 void procE2NodeConfigUpdateFailure(E2AP_PDU_t *e2apMsg)
838 uint8_t arrIdx =0, transId =0, timerValue=0;
839 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
841 DU_LOG("\nINFO --> E2AP : E2 Node Config Update failure received");
842 e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
844 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
846 switch(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->id)
848 case ProtocolIE_IDE2_id_TransactionID:
850 transId = e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
851 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
852 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
854 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
858 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
862 case ProtocolIE_IDE2_id_TimeToWaitE2:
864 timerValue = convertE2WaitTimerEnumToValue(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
865 if((duChkTmr((PTR)&(duCb.e2apDb), EVENT_E2_NODE_CONFIG_UPDATE_TMR)) == FALSE)
867 duStartTmr((PTR)&(duCb.e2apDb), EVENT_E2_NODE_CONFIG_UPDATE_TMR, timerValue);
871 DU_LOG("\nERROR --> E2AP : EVENT_E2_NODE_CONFIG_UPDATE_TMR timer is already running");
878 freeAperDecodingOfE2NodeConfigUpdateFailure(e2NodeCfgUpdFail);
881 /*******************************************************************
883 * @brief Builds Global gNodeB Params
887 * Function : BuildGlobalgNBId
889 * Functionality: Building the Plmn and gNB id
891 * @params[in] GlobalE2node_gNB_ID_t *gNbId
892 * @return ROK - success
895 ******************************************************************/
897 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
900 uint8_t byteSize = 4;
901 uint8_t gnbId = duCb.gnbId;
904 /* fill Global gNB ID Id */
905 gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
906 gNbId->global_gNB_ID.plmn_id.buf = NULLP;
907 DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
908 if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
910 DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
915 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
916 gNbId->global_gNB_ID.plmn_id.buf);
917 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
918 /* Allocate Buffer size */
919 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
920 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
921 DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
922 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
923 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
925 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
930 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId);
935 DU_ALLOC( gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
936 if(gNbId->gNB_DU_ID == NULLP)
938 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID ");
943 gNbId->gNB_DU_ID->size = sizeof(uint8_t);
944 DU_ALLOC( gNbId->gNB_DU_ID->buf, sizeof(uint8_t));
945 if(gNbId->gNB_DU_ID->buf)
947 gNbId->gNB_DU_ID->buf[0] =duCb.e2apDb.e2NodeId;
951 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID buffer");
959 /*******************************************************************
961 * @brief fill the E2 node config information
965 * Function : fillE2NodeConfig
967 * Functionality: fill E2 node config information
970 * Pointer to e2NodeCfg to be filled
971 * E2 Node Component information
972 * Type of configuration
973 * @return ROK - success
976 ******************************************************************/
978 uint8_t fillE2NodeConfig(PTR e2NodeCfg, E2NodeComponent *e2NodeComponentInfo, ConfigType configType)
980 E2NodeConfig *e2NodeConfig=NULLP;
981 E2nodeComponentInterfaceType_t *interfaceType=NULLP;
982 E2nodeComponentID_t *componentID =NULLP;
983 E2nodeComponentConfiguration_t *configuration=NULLP;
984 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
985 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULL;
986 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
992 e2NodeAddItem = (E2nodeComponentConfigAddition_Item_t*)e2NodeCfg;
993 interfaceType = &e2NodeAddItem->e2nodeComponentInterfaceType;
994 componentID = &e2NodeAddItem->e2nodeComponentID;
995 configuration = &e2NodeAddItem->e2nodeComponentConfiguration;
996 e2NodeConfig = e2NodeComponentInfo->addConfiguration;
1001 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_Item_t *) e2NodeCfg;
1002 interfaceType = &e2NodeUpdateItem->e2nodeComponentInterfaceType;
1003 componentID = &e2NodeUpdateItem->e2nodeComponentID;
1004 configuration = &e2NodeUpdateItem->e2nodeComponentConfiguration;
1005 e2NodeConfig = e2NodeComponentInfo->updateConfiguration;
1010 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_Item_t*) e2NodeCfg;
1011 interfaceType = &e2NodeRemovalItem->e2nodeComponentInterfaceType;
1012 componentID = &e2NodeRemovalItem->e2nodeComponentID;
1017 DU_LOG("\nERROR --> E2AP : Configuration type %d does not supported ", configType);
1021 /* E2nodeComponentInterfaceType */
1022 *interfaceType = convertInterfaceToE2ComponentInterfaceType(e2NodeComponentInfo->interfaceType);
1024 /* We now only support the F1 interface out of these interfaces
1025 * (NG,XN,E1,F1,W1,S1,X2), therefore only the F1 component identifier was filled in. */
1027 if(*interfaceType == F1)
1029 /* E2 Node Component ID */
1030 componentID->present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
1031 DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1,sizeof(E2nodeComponentInterfaceF1_t));
1032 if(componentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
1034 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1037 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
1038 DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
1039 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1041 if(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
1043 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1046 memcpy(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, &e2NodeComponentInfo->componentId,\
1047 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1050 if(configType == CONFIG_DEL)
1052 /* We don't need to fill out the E2 Node Component Request and Response
1053 * information in the case of CONFIG_DEL, therefore returning ROK from here. */
1057 /* E2 Node Component Request Part */
1058 if(e2NodeConfig->componentRequestPart)
1060 configuration->e2nodeComponentRequestPart.size = e2NodeConfig->reqBufSize ;
1061 DU_ALLOC(configuration->e2nodeComponentRequestPart.buf,\
1062 configuration->e2nodeComponentRequestPart.size);
1063 if(configuration->e2nodeComponentRequestPart.buf == NULLP)
1065 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1069 memcpy(configuration->e2nodeComponentRequestPart.buf,\
1070 e2NodeConfig->componentRequestPart, configuration->\
1071 e2nodeComponentRequestPart.size);
1075 DU_LOG("\nERROR --> E2AP: componentRequestPart is null ");
1079 /* E2 Node Component Response Part */
1080 if(e2NodeConfig->componentResponsePart)
1082 configuration->e2nodeComponentResponsePart.size = e2NodeConfig->rspBufSize;
1083 DU_ALLOC(configuration->e2nodeComponentResponsePart.buf, configuration->e2nodeComponentResponsePart.size);
1084 if(configuration->e2nodeComponentResponsePart.buf == NULLP)
1086 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
1089 memcpy(configuration->e2nodeComponentResponsePart.buf, e2NodeConfig->componentResponsePart, configuration->\
1090 e2nodeComponentResponsePart.size);
1094 DU_LOG("\nERROR --> E2AP: componentResponsePart is null");
1101 /*******************************************************************
1103 * @brief Builds E2 node config addition list
1107 * Function : BuildE2NodeConfigAddList
1109 * Functionality: Building E2 node config addition list
1112 * E2nodeComponentConfigAddition_List_t to be filled
1114 * Count of E2 node to be added in the list
1115 * Received list of E2 node configuration
1117 * @return ROK - success
1120 ******************************************************************/
1122 uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAddList, uint8_t procedureCode, uint16_t count, E2NodeConfigItem *e2NodeList)
1125 CmLList *node =NULL;
1126 E2NodeComponent *e2NodeComponentInfo=NULL;
1127 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe=NULL;
1128 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
1131 /* For ProcedureCodeE2_id_E2setup, the number of E2 node configuration list items is
1132 * equal to the number of E2 node configuration entries stored in the database.
1133 * For any other procedure, the E2 node configuration list count is equal
1134 * to the count of E2 node configuration obtained from the function's caller */
1136 if(procedureCode == ProcedureCodeE2_id_E2setup)
1137 e2NodeAddList->list.count = duCb.e2apDb.e2NodeComponentList.count;
1139 e2NodeAddList->list.count = count;
1141 e2NodeAddList->list.size = e2NodeAddList->list.count * sizeof(E2nodeComponentConfigAddition_ItemIEs_t *);
1142 DU_ALLOC(e2NodeAddList->list.array, e2NodeAddList->list.size);
1143 if(e2NodeAddList->list.array == NULLP)
1145 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
1149 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
1151 DU_ALLOC(e2NodeAddList->list.array[arrIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
1152 if(e2NodeAddList->list.array[arrIdx] == NULLP)
1154 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
1158 if(procedureCode == ProcedureCodeE2_id_E2setup)
1160 /* Getting all of the E2 node configuration's information from DuCb one by one*/
1163 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
1171 DU_LOG("\nERROR --> E2AP : E2 node component list node is null");
1174 e2NodeComponentInfo = (E2NodeComponent*)node->node;
1178 /* Getting only those E2 node configuration from DuCb whose interface
1179 * and action type is present in the received array */
1180 e2NodeComponentInfo = fetchE2NodeComponentInfo(e2NodeList[arrIdx].interface, e2NodeList[arrIdx].componentId, &node);
1183 if(!e2NodeComponentInfo)
1185 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1189 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
1190 e2NodeAddItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition_Item;
1191 e2NodeAddItemIe->criticality = CriticalityE2_reject;
1192 e2NodeAddItemIe->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
1193 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
1194 if(fillE2NodeConfig((PTR)e2NodeAddItem, e2NodeComponentInfo, CONFIG_ADD) != ROK)
1196 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1203 /*******************************************************************
1205 * @brief Builds E2 node config update list
1209 * Function : BuildE2NodeConfigUpdateList
1211 * Functionality: Building E2 node config update list
1214 * E2nodeComponentConfigUpdate_List_t to be filled
1215 * Count of E2 node to be update in the list
1216 * Received list of E2 node configuration
1218 * @return ROK - success
1221 ******************************************************************/
1223 uint8_t BuildE2NodeConfigUpdateList(E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList, uint16_t count, E2NodeConfigItem *updateE2Node)
1226 CmLList *node =NULL;
1227 E2NodeComponent *e2NodeComponentInfo =NULL;
1228 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe =NULL;
1229 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULL;
1231 e2NodeUpdateList->list.count = count;
1232 e2NodeUpdateList->list.size = e2NodeUpdateList->list.count * sizeof(E2nodeComponentConfigUpdate_ItemIEs_t *);
1233 DU_ALLOC(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
1234 if(e2NodeUpdateList->list.array == NULLP)
1236 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
1240 for(arrIdx = 0; arrIdx< e2NodeUpdateList->list.count; arrIdx++)
1242 DU_ALLOC(e2NodeUpdateList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
1243 if(e2NodeUpdateList->list.array[arrIdx] == NULLP)
1245 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
1249 e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface, updateE2Node[arrIdx].componentId, &node);
1250 if(!e2NodeComponentInfo)
1252 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1256 e2NodeUpdateItemIe = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[arrIdx];
1257 e2NodeUpdateItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate_Item;
1258 e2NodeUpdateItemIe->criticality = CriticalityE2_reject;
1259 e2NodeUpdateItemIe->value.present = E2nodeComponentConfigUpdate_ItemIEs__value_PR_E2nodeComponentConfigUpdate_Item;
1260 e2NodeUpdateItem = &e2NodeUpdateItemIe->value.choice.E2nodeComponentConfigUpdate_Item;
1262 if(fillE2NodeConfig((PTR)e2NodeUpdateItem, e2NodeComponentInfo, CONFIG_MOD) != ROK)
1264 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1274 /*******************************************************************
1276 * @brief Builds E2 node config remove list
1280 * Function :BuildE2NodeConfigRemoveList
1282 * Functionality: Building E2 node config remove list
1285 * E2nodeComponentConfigRemoval_List_t to be filled
1286 * Count of E2 node to be remove in the list
1287 * Received list of E2 node configuration
1288 * @return ROK - success
1291 ******************************************************************/
1293 uint8_t BuildE2NodeConfigRemoveList(E2nodeComponentConfigRemoval_List_t *e2NodeRemoveList, uint16_t count, E2NodeConfigItem *updateE2Node)
1297 E2NodeComponent *e2NodeComponentInfo=NULL;
1298 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItemIe=NULL;
1299 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
1301 e2NodeRemoveList->list.count = count;
1302 e2NodeRemoveList->list.size = e2NodeRemoveList->list.count * sizeof(E2nodeComponentConfigRemoval_ItemIEs_t *);
1303 DU_ALLOC(e2NodeRemoveList->list.array, e2NodeRemoveList->list.size);
1304 if(e2NodeRemoveList->list.array == NULLP)
1306 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
1310 for(arrIdx = 0; arrIdx< e2NodeRemoveList->list.count; arrIdx++)
1312 DU_ALLOC(e2NodeRemoveList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
1313 if(e2NodeRemoveList->list.array[arrIdx] == NULLP)
1315 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
1319 e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface,updateE2Node[arrIdx].componentId, &node);
1320 if(!e2NodeComponentInfo)
1322 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
1326 e2NodeRemovalItemIe = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemoveList->list.array[arrIdx];
1327 e2NodeRemovalItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval_Item;
1328 e2NodeRemovalItemIe->criticality = CriticalityE2_reject;
1329 e2NodeRemovalItemIe->value.present = E2nodeComponentConfigRemoval_ItemIEs__value_PR_E2nodeComponentConfigRemoval_Item;
1330 e2NodeRemovalItem = &e2NodeRemovalItemIe->value.choice.E2nodeComponentConfigRemoval_Item;
1332 if(fillE2NodeConfig((PTR)e2NodeRemovalItem, e2NodeComponentInfo, CONFIG_DEL) != ROK)
1334 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
1341 /*******************************************************************
1343 * @brief deallocation of E2SM_KPM_RANfunction_Description_t
1347 * Function : freeE2smKpmRanFunctionDefinition
1349 * Functionality: deallocation of E2SM_KPM_RANfunction_Description_t
1351 * @params[in] E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition
1354 ******************************************************************/
1356 void freeE2smKpmRanFunctionDefinition(E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition)
1358 MeasurementInfo_Action_Item_t *measInfoList;
1359 uint8_t eventTriggerIdx, reportStyleIdx, measInfoIdx;
1360 RANfunction_Name_t *ranFuncName;
1361 struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle;
1362 struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *eventTriggerStyle;
1363 if(ranFunctionDefinition)
1365 ranFuncName = &ranFunctionDefinition->ranFunction_Name;
1366 /* Free RAN function Name */
1367 DU_FREE(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
1368 DU_FREE(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
1369 DU_FREE(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
1371 /* Sequence of Event Trigger styles */
1372 eventTriggerStyle = ranFunctionDefinition->ric_EventTriggerStyle_List;
1373 if(eventTriggerStyle)
1375 if(eventTriggerStyle->list.array)
1377 for(eventTriggerIdx =0;eventTriggerIdx<eventTriggerStyle->list.count; eventTriggerIdx++)
1379 if(eventTriggerStyle->list.array[eventTriggerIdx])
1381 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.buf,\
1382 eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.size);
1383 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
1386 DU_FREE(eventTriggerStyle->list.array, eventTriggerStyle->list.size)
1388 DU_FREE(eventTriggerStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
1391 /* Sequence of Report styles */
1392 ricReportStyle = ranFunctionDefinition->ric_ReportStyle_List;
1395 if(ricReportStyle->list.array)
1397 for(reportStyleIdx =0;reportStyleIdx<ricReportStyle->list.count; reportStyleIdx++)
1399 if(ricReportStyle->list.array[reportStyleIdx])
1401 if(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf)
1403 DU_FREE(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf,\
1404 ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.size);
1406 if(ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array)
1408 for(measInfoIdx=0; measInfoIdx<ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.count; \
1411 measInfoList = ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array[measInfoIdx];
1414 DU_FREE(measInfoList->measID, sizeof(long));
1415 DU_FREE(measInfoList->measName.buf, measInfoList->measName.size);
1416 DU_FREE(measInfoList,sizeof(MeasurementInfo_Action_Item_t));
1419 DU_FREE(measInfoList,ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.size);
1421 DU_FREE(ricReportStyle->list.array[reportStyleIdx], sizeof(RIC_ReportStyle_Item_t));
1424 DU_FREE(ricReportStyle->list.array, ricReportStyle->list.size);
1426 DU_FREE(ricReportStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1428 DU_FREE(ranFunctionDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1432 /*******************************************************************
1434 * @brief fill the e2sm ric report style
1438 * Function : fillRicReportStyle
1440 * Functionality: fill the report style
1442 * @params[in] RanFunction *ranFuncDb, struct
1443 * E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle
1444 * @return ROK - success
1447 ******************************************************************/
1448 uint8_t fillRicReportStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle)
1450 uint8_t styleIdx, measInfoIdx;
1451 MeasurementInfo_Action_List_t *measInfo;
1454 ricReportStyle->list.count = ranFuncDb->numOfReportStyleSupported;
1455 ricReportStyle->list.size = ricReportStyle->list.count * sizeof(RIC_ReportStyle_Item_t*);
1456 DU_ALLOC(ricReportStyle->list.array, ricReportStyle->list.size);
1457 if(!ricReportStyle->list.array)
1459 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__);
1463 for(styleIdx =0;styleIdx<ricReportStyle->list.count; styleIdx++)
1465 DU_ALLOC(ricReportStyle->list.array[styleIdx], sizeof(RIC_ReportStyle_Item_t));
1466 if(!ricReportStyle->list.array[styleIdx])
1468 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1472 /* RIC Report Style Type */
1473 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType;
1475 /* RIC Report Style Format Type */
1476 ricReportStyle->list.array[styleIdx]->ric_ActionFormat_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType;
1478 /* RIC Report Style Name */
1479 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size = strlen(ranFuncDb->reportStyleList[styleIdx].reportStyle.name);
1480 DU_ALLOC(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf,\
1481 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1482 if(!ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf)
1484 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1487 memcpy(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf, ranFuncDb->reportStyleList[styleIdx].reportStyle.name,\
1488 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1490 /* RIC Indication Header Format Type*/
1491 ricReportStyle->list.array[styleIdx]->ric_IndicationHeaderFormat_Type = ranFuncDb->ricIndicationHeaderFormat;
1493 /* RIC Indication Message Format Type*/
1494 ricReportStyle->list.array[styleIdx]->ric_IndicationMessageFormat_Type = ranFuncDb->ricIndicationMessageFormat;
1496 /* Measurement Info Action List */
1497 CmLListCp measInfoList =ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
1498 if(!measInfoList.count)
1503 CM_LLIST_FIRST_NODE(&ranFuncDb->reportStyleList[styleIdx].measurementInfoList, node);
1504 measInfo = &ricReportStyle->list.array[styleIdx]->measInfo_Action_List;
1506 measInfo->list.count = measInfoList.count;
1507 measInfo->list.size = measInfoList.count*sizeof(MeasurementInfo_Action_Item_t*);
1508 DU_ALLOC(measInfo->list.array, measInfo->list.size);
1509 if(!measInfo->list.array)
1511 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1515 for(measInfoIdx=0; measInfoIdx<measInfo->list.count; measInfoIdx++)
1519 DU_LOG("\nERROR --> E2AP: Measurement info node is null");
1523 DU_ALLOC(measInfo->list.array[measInfoIdx],sizeof(MeasurementInfo_Action_Item_t));
1524 if(!measInfo->list.array[measInfoIdx])
1526 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1529 MeasurementInfoForAction *measInfoForAction= (MeasurementInfoForAction*)node->node;
1530 DU_ALLOC(measInfo->list.array[measInfoIdx]->measID, sizeof(long));
1531 if(!measInfo->list.array[measInfoIdx]->measID)
1533 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1537 memcpy(measInfo->list.array[measInfoIdx]->measID, &measInfoForAction->measurementTypeId,sizeof(long));
1538 measInfo->list.array[measInfoIdx]->measName.size= strlen(measInfoForAction->measurementTypeName);
1539 DU_ALLOC(measInfo->list.array[measInfoIdx]->measName.buf, measInfo->list.array[measInfoIdx]->measName.size);
1540 if(!measInfo->list.array[measInfoIdx]->measName.size)
1542 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1546 memcpy(measInfo->list.array[measInfoIdx]->measName.buf, \
1547 measInfoForAction->measurementTypeName,\
1548 measInfo->list.array[measInfoIdx]->measName.size);
1555 /*******************************************************************
1557 * @brief fill the ric event trigger style
1561 * Function : fillRicEventTriggerStyle
1563 * Functionality: fill the ric event trigger style
1566 * @return ROK - success
1569 ******************************************************************/
1570 uint8_t fillRicEventTriggerStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *ricEventTriggerStyle)
1574 ricEventTriggerStyle->list.count = ranFuncDb->numOfEventTriggerStyleSupported;
1575 ricEventTriggerStyle->list.size = ricEventTriggerStyle->list.count* sizeof(RIC_EventTriggerStyle_Item_t *);
1576 DU_ALLOC(ricEventTriggerStyle->list.array, ricEventTriggerStyle->list.size);
1577 if(!ricEventTriggerStyle->list.array)
1579 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__);
1583 for(styleIdx =0;styleIdx<ricEventTriggerStyle->list.count; styleIdx++)
1585 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
1586 if(!ricEventTriggerStyle->list.array[styleIdx])
1588 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1591 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Type = ranFuncDb->eventTriggerStyleList[styleIdx].styleType;
1593 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerFormat_Type = ranFuncDb->eventTriggerStyleList[styleIdx].formatType;
1595 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size = strlen(ranFuncDb->eventTriggerStyleList[styleIdx].name);
1596 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,\
1597 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1598 if(!ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf)
1600 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1603 memcpy(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,ranFuncDb->eventTriggerStyleList[styleIdx].name,\
1604 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1610 /*******************************************************************
1612 * @brief Builds Ran function item
1616 * Function : BuildRanFunctionItem
1618 * Functionality: Building RAN function item
1621 * RAN function item that has to be filled
1622 * Stored RAN Function information
1623 * @return ROK - success
1626 ******************************************************************/
1628 uint8_t BuildRanFunctionItem(RANfunction_Item_t *ranFuncItem, RanFunction *ranFuncDb)
1630 uint8_t ret =RFAILED;
1631 RANfunctionDefinition_t *ranFunctionDefinition;
1632 RANfunction_Name_t *ranFuncName;
1633 asn_enc_rval_t encRetVal;
1634 E2SM_KPM_RANfunction_Description_t *ranFuncDefinition;
1638 /* RAN function Id*/
1639 ranFuncItem->ranFunctionID = ranFuncDb->id;
1641 /* RAN Function Revision*/
1642 ranFuncItem->ranFunctionRevision = ranFuncDb->revisionCounter;
1644 /* RAN function OID*/
1645 ranFuncItem->ranFunctionOID.size = strlen(ranFuncDb->name.serviceModelOID);
1646 DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size);
1647 if(!ranFuncItem->ranFunctionOID.buf)
1649 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1652 memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size);
1654 /* RAN function Definition */
1655 DU_ALLOC(ranFuncDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1656 if(!ranFuncDefinition)
1658 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1662 /* RAN function Name */
1663 ranFuncName = &ranFuncDefinition->ranFunction_Name;
1665 /* RAN function ShortName */
1666 ranFuncName->ranFunction_ShortName.size = strlen(ranFuncDb->name.shortName);
1667 DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
1668 if(!ranFuncName->ranFunction_ShortName.buf)
1670 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1673 memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName));
1675 /* RAN function E2SM_OID */
1676 ranFuncName->ranFunction_E2SM_OID.size = strlen(ranFuncDb->name.serviceModelOID);
1677 DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
1678 if(!ranFuncName->ranFunction_E2SM_OID.buf)
1680 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1683 memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
1685 /* RAN Function Name Description */
1686 ranFuncName->ranFunction_Description.size = strlen(ranFuncDb->name.description);
1687 DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
1688 if(!ranFuncName->ranFunction_Description.buf)
1690 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1693 memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size);
1695 /* RIC Event Trigger Style List */
1696 DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
1697 if(!ranFuncDefinition->ric_EventTriggerStyle_List)
1699 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1703 if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
1705 DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
1709 /* RIC Report Style List */
1710 DU_ALLOC(ranFuncDefinition->ric_ReportStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1711 if(!ranFuncDefinition->ric_ReportStyle_List)
1713 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1716 if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
1718 DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
1722 /* Encode the F1SetupRequest type as APER */
1723 xer_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, ranFuncDefinition);
1725 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1727 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_RANfunction_Description, 0, ranFuncDefinition, PrepFinalEncBuf, encBuf);
1729 /* Encode results */
1730 if(encRetVal.encoded == ENCODE_FAIL)
1732 DU_LOG("\nERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\
1733 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1738 DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n");
1739 for(uint8_t measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
1741 printf("%x",encBuf[measIeIdx]);
1743 ranFunctionDefinition = &ranFuncItem->ranFunctionDefinition;
1744 ranFunctionDefinition->size = encBufSize;
1745 DU_ALLOC(ranFunctionDefinition->buf, encBufSize);
1746 if(ranFunctionDefinition->buf == NULLP)
1748 DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
1751 memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize);
1756 freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
1760 /*******************************************************************
1762 * @brief Builds Ran function add list based on the procedure code
1766 * Function : BuildRanFunctionAddList
1768 * Functionality: Building RAN addition addition list
1769 * In case of ProcedureCodeE2_id_E2setup we add all the RAN Function list
1770 * which is present in E2 database.
1771 * In the case of other procedures, we just fill the RAN functions whose ID
1772 * is contained in recvList
1777 * Count of ran functions to be added in the list
1778 * Received list of RAN functions
1780 * @return ROK - success
1783 ******************************************************************/
1785 uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList, uint8_t procedureCode, uint8_t count, RanFuncInfo *recvList)
1788 RanFunction *ranFuncDb;
1790 RANfunction_ItemIEs_t *ranFuncItemIe;
1792 /* For ProcedureCodeE2_id_E2setup, the number of RAN function list items is
1793 * equal to the number of ran function entries stored in the database.
1794 * For any other procedure, the RAN function list count is equal
1795 * to the count of ran functions obtained from the function's caller */
1797 if(procedureCode == ProcedureCodeE2_id_E2setup)
1798 ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
1800 ranFunctionsList->list.count = count;
1802 ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*);
1803 DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
1804 if(ranFunctionsList->list.array == NULLP)
1806 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1810 for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++)
1812 DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1813 if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
1815 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1818 if(procedureCode == ProcedureCodeE2_id_E2setup)
1820 /* Getting all of the RAN function's information from DuCb one by one*/
1821 ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
1825 /* Getting only the RAN function information from DuCb whose Id is
1826 * present in the received array */
1827 id =recvList[ranFuncIdx].id;
1828 ranFuncDb = &duCb.e2apDb.ranFunction[id-1];
1830 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1831 ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item;
1832 ranFuncItemIe->criticality = CriticalityE2_ignore;
1833 ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
1834 BuildRanFunctionItem(&ranFuncItemIe->value.choice.RANfunction_Item, ranFuncDb);
1839 /*******************************************************************
1841 * @brief De Allocate E2 Setup Request Message
1845 * Function : FreeE2SetupReq
1847 * Functionality: De-Allocating E2 Setup request Message
1849 * @params[in] E2AP_PDU_t *e2apMsg
1853 * ****************************************************************/
1855 void FreeE2SetupReq(E2AP_PDU_t *e2apMsg)
1858 uint8_t e2NodeAddListIdx =0, ranFuncAddListIdx;
1859 E2setupRequest_t *e2SetupReq;
1860 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1861 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1862 RANfunctions_List_t *ranFunctionsList;
1863 RANfunction_ItemIEs_t *ranFuncItemIe;
1864 RANfunction_Item_t *ranFunItem;
1866 /* De-allocating Memory */
1867 if(e2apMsg != NULLP)
1869 if(e2apMsg->choice.initiatingMessage != NULLP)
1871 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
1872 if(e2SetupReq->protocolIEs.list.array != NULLP)
1874 for(arrIdx = 0; arrIdx < e2SetupReq->protocolIEs.list.count; arrIdx++)
1876 if(e2SetupReq->protocolIEs.list.array[arrIdx] != NULLP)
1878 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1880 case ProtocolIE_IDE2_id_TransactionID:
1882 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1884 if(e2SetupReq->protocolIEs.list.array[arrIdx]->\
1885 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
1887 GlobalE2node_gNB_ID_t *gNbId = NULLP;
1888 gNbId = e2SetupReq->protocolIEs.list.array[arrIdx]->\
1889 value.choice.GlobalE2node_ID.choice.gNB;
1890 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
1892 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
1893 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
1894 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
1895 gNbId->global_gNB_ID.plmn_id.size);
1898 if(gNbId->gNB_DU_ID != NULLP)
1900 DU_FREE( gNbId->gNB_DU_ID->buf, gNbId->gNB_DU_ID->size);
1901 DU_FREE(gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
1903 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
1904 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
1908 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1910 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1911 if(e2NodeAddList->list.array)
1913 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1915 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
1917 /* Free E2 Node Component Request Part */
1918 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
1919 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
1921 /* Free E2 Node Component Response Part */
1922 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.\
1923 e2nodeComponentResponsePart.buf, \
1924 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
1926 /* Free E2 Node Component ID */
1927 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1)
1929 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1930 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
1931 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1932 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1933 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
1934 sizeof(E2nodeComponentInterfaceF1_t));
1936 DU_FREE(e2NodeAddList->list.array[e2NodeAddListIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
1938 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
1942 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1944 ranFunctionsList = &(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
1945 if(ranFunctionsList->list.array)
1947 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
1949 if(ranFunctionsList->list.array[ranFuncAddListIdx])
1951 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
1952 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1953 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
1954 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
1955 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
1958 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
1964 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
1965 (e2SetupReq->protocolIEs.list.array[arrIdx]->id));
1968 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx], sizeof(E2setupRequestIEs_t));
1971 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
1973 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1975 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1979 /*******************************************************************
1981 * @brief Builds and Send the E2SetupRequest
1985 * Function : BuildAndSendE2SetupReq
1987 * Functionality:Fills the E2SetupRequest
1989 * @return ROK - success
1992 ******************************************************************/
1994 uint8_t BuildAndSendE2SetupReq()
1996 uint8_t arrIdx = 0, elementCnt=0;
1997 uint8_t transId = 0, ret = RFAILED;
1998 bool memAllocFailed = false;
1999 E2AP_PDU_t *e2apMsg = NULLP;
2000 E2setupRequest_t *e2SetupReq = NULLP;
2001 asn_enc_rval_t encRetVal; /* Encoder return value */
2003 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
2006 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2007 if(e2apMsg == NULLP)
2009 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2012 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2013 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2014 if(e2apMsg->choice.initiatingMessage == NULLP)
2016 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2019 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2020 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
2021 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
2022 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
2025 e2SetupReq->protocolIEs.list.count = elementCnt;
2026 e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*);
2028 /* Initialize the E2Setup members */
2029 DU_ALLOC(e2SetupReq->protocolIEs.list.array, \
2030 e2SetupReq->protocolIEs.list.size);
2031 if(e2SetupReq->protocolIEs.list.array == NULLP)
2033 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
2036 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
2038 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx],\
2039 sizeof(E2setupRequestIEs_t));
2040 if(e2SetupReq->protocolIEs.list.array[arrIdx] == NULLP)
2042 memAllocFailed = true;
2043 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
2047 if(memAllocFailed == true)
2053 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2054 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2055 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
2056 transId = assignTransactionId();
2057 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2060 /* GlobalE2node_gNB_ID */
2061 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
2062 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2063 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
2064 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
2066 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
2067 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
2068 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
2069 GlobalE2node_ID.choice.gNB == NULLP)
2071 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
2076 ret = BuildGlobalgNBId(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
2077 choice.GlobalE2node_ID.choice.gNB);
2080 DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
2085 /* RAN Functions Added List */
2087 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
2088 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2089 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
2090 if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
2092 DU_LOG("\nERROR --> E2AP : Failed to create RAN Function");
2096 /* E2 Node Component Configuration Addition List */
2098 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
2099 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2100 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
2101 if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
2103 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
2109 /* Prints the Msg formed */
2110 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2112 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2114 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
2116 if(encRetVal.encoded == ENCODE_FAIL)
2118 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
2119 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2124 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
2125 #ifdef DEBUG_ASN_PRINT
2126 for(int i=0; i< encBufSize; i++)
2128 printf("%x",encBuf[i]);
2132 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2134 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
2139 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
2140 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
2142 FreeE2SetupReq(e2apMsg);
2144 }/* End of BuildAndSendE2SetupReq */
2146 /*******************************************************************
2148 * @brief Builds RIC Action Admitted List
2152 * Function : BuildRicActionAdmitList
2154 * Functionality: Builds RIC Action Admitted List
2156 * @params[in] Pointer to RIC Action Admitted List to be filled
2157 * Subscription Response information
2158 * @return ROK - success
2161 * ****************************************************************/
2162 uint8_t BuildRicActionAdmitList(RICaction_Admitted_List_t *admitList, PendingSubsRspInfo *subsRspInfo)
2165 uint8_t elementCnt = 0;
2166 RICaction_Admitted_ItemIEs_t *admitItem = NULLP;
2168 elementCnt = subsRspInfo->numOfAcceptedActions;
2170 admitList->list.count = elementCnt;
2171 admitList->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t *);
2173 DU_ALLOC(admitList->list.array, admitList->list.size);
2174 if(admitList->list.array == NULLP)
2176 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2180 for(idx=0; idx<elementCnt; idx++)
2182 DU_ALLOC(admitList->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
2183 if(admitList->list.array[idx] == NULLP)
2185 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2189 admitItem = (RICaction_Admitted_ItemIEs_t *)admitList->list.array[idx];
2190 admitItem->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
2191 admitItem->criticality = CriticalityE2_reject;
2192 admitItem->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
2193 admitItem->value.choice.RICaction_Admitted_Item.ricActionID = subsRspInfo->acceptedActionList[idx];
2198 /*******************************************************************
2200 * @brief Builds RIC Action Not Admitted List
2204 * Function : BuildRicActionNotAdmitList
2206 * Functionality: Builds RIC Action Not Admitted List
2208 * @params[in] Pointer to RIC Action Not Admitted List to be filled
2209 * Subscription Response information
2210 * @return ROK - success
2213 * ****************************************************************/
2214 uint8_t BuildRicActionNotAdmitList(RICaction_NotAdmitted_List_t *notAdmitList, PendingSubsRspInfo *subsRspInfo)
2217 uint8_t elementCnt = 0;
2218 RICaction_NotAdmitted_ItemIEs_t *notAdmitItem = NULLP;
2220 elementCnt = subsRspInfo->numOfRejectedActions;
2222 notAdmitList->list.count = elementCnt;
2223 notAdmitList->list.size = elementCnt * sizeof(RICaction_NotAdmitted_ItemIEs_t *);
2225 DU_ALLOC(notAdmitList->list.array, notAdmitList->list.size);
2226 if(notAdmitList->list.array == NULLP)
2228 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2232 for(idx=0; idx<elementCnt; idx++)
2234 DU_ALLOC(notAdmitList->list.array[idx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
2235 if(notAdmitList->list.array[idx] == NULLP)
2237 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2241 notAdmitItem = (RICaction_NotAdmitted_ItemIEs_t *)notAdmitList->list.array[idx];
2242 notAdmitItem->id = ProtocolIE_IDE2_id_RICaction_NotAdmitted_Item;
2243 notAdmitItem->criticality = CriticalityE2_reject;
2244 notAdmitItem->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;
2245 notAdmitItem->value.choice.RICaction_NotAdmitted_Item.ricActionID = \
2246 subsRspInfo->rejectedActionList[idx].id;
2247 fillE2Cause(¬AdmitItem->value.choice.RICaction_NotAdmitted_Item.cause, \
2248 subsRspInfo->rejectedActionList[idx].failureCause);
2253 /*******************************************************************
2255 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
2259 * Function : FreeRicSubscriptionRsp
2261 * Functionality:Free the RicSubscriptionRsp
2263 * @param[in] E2AP_PDU_t *e2apRicMsg
2267 ******************************************************************/
2268 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
2270 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
2273 RICaction_Admitted_List_t *admitList = NULLP;
2274 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
2276 if(e2apRicMsg != NULLP)
2278 if(e2apRicMsg->choice.successfulOutcome != NULLP)
2280 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2281 if(ricSubscriptionRsp)
2283 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
2285 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
2287 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
2289 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
2291 case ProtocolIE_IDE2_id_RICactions_Admitted:
2293 admitList = &ricSubscriptionRsp->protocolIEs.list.\
2294 array[idx]->value.choice.RICaction_Admitted_List;
2295 if(admitList->list.array != NULLP)
2297 for(listIdx=0 ; listIdx < admitList->list.count; listIdx++)
2299 DU_FREE(admitList->list.array[listIdx], sizeof(RICaction_Admitted_ItemIEs_t));
2301 DU_FREE(admitList->list.array, admitList->list.size);
2305 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
2307 notAdmitList = &ricSubscriptionRsp->protocolIEs.list.\
2308 array[idx]->value.choice.RICaction_NotAdmitted_List;
2309 if(notAdmitList->list.array != NULLP)
2311 for(listIdx=0 ; listIdx < notAdmitList->list.count; listIdx++)
2313 DU_FREE(notAdmitList->list.array[listIdx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
2315 DU_FREE(notAdmitList->list.array, notAdmitList->list.size);
2322 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], sizeof(RICsubscriptionResponse_IEs_t));
2325 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
2328 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2330 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
2334 /*******************************************************************
2336 * @brief Fill RIC Subscription Response IEs
2340 * Function : fillRicSubscriptionRsp
2342 * functionality: Fill RIC Subscription Response IEs
2344 * @param Pointer to RIC subscription response
2345 * Subscription response information
2346 * @return ROK - success
2349 ******************************************************************/
2350 uint8_t fillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp, PendingSubsRspInfo *subsRspInfo)
2353 uint8_t elementCnt = 0;
2354 RICsubscriptionResponse_IEs_t *subsRspIe = NULLP;
2357 if(subsRspInfo->numOfRejectedActions)
2360 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
2361 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
2362 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
2363 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
2365 DU_LOG("\nERROR --> E2AP : Memory allocation failed at %s : line %d", __func__, __LINE__);
2369 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
2371 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionResponse_IEs_t));
2372 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx] == NULLP)
2374 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d] : ieIdx [%d]", __func__, __LINE__,ieIdx);
2379 /* RIC Request ID */
2381 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2382 subsRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
2383 subsRspIe->criticality = CriticalityE2_reject;
2384 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
2385 subsRspIe->value.choice.RICrequestID.ricRequestorID = subsRspInfo->requestId.requestorId;
2386 subsRspIe->value.choice.RICrequestID.ricInstanceID = subsRspInfo->requestId.instanceId;
2388 /* RAN Function ID */
2390 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2391 subsRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
2392 subsRspIe->criticality = CriticalityE2_reject;
2393 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
2394 subsRspIe->value.choice.RANfunctionID = subsRspInfo->ranFuncId;
2396 /* RIC Action Admitted List */
2398 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2399 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_Admitted;
2400 subsRspIe->criticality = CriticalityE2_reject;
2401 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
2402 if(BuildRicActionAdmitList(&subsRspIe->value.choice.RICaction_Admitted_List, subsRspInfo) != ROK)
2404 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Admitted List in RIC Subscription Response");
2408 /* RIC Action Not Admitted List */
2409 if(subsRspInfo->numOfRejectedActions)
2412 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2413 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_NotAdmitted;
2414 subsRspIe->criticality = CriticalityE2_reject;
2415 subsRspIe->criticality = CriticalityE2_reject;
2416 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
2417 if(BuildRicActionNotAdmitList(&subsRspIe->value.choice.RICaction_NotAdmitted_List, subsRspInfo) != ROK)
2419 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Not Admitted List in RIC Subscription Response");
2427 /*******************************************************************
2429 * @brief Builds and Send the RicSubscriptionRsp
2433 * Function : BuildAndSendRicSubscriptionRsp
2435 * Functionality:Fills the RicSubscriptionRsp
2437 * @return ROK - success
2440 ******************************************************************/
2442 uint8_t BuildAndSendRicSubscriptionRsp(PendingSubsRspInfo *subsRspInfo)
2444 uint8_t ret = RFAILED;
2445 E2AP_PDU_t *e2apRicMsg = NULLP;
2446 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
2447 asn_enc_rval_t encRetVal;
2451 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
2453 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
2454 if(e2apRicMsg == NULLP)
2456 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2460 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
2461 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2462 if(e2apRicMsg->choice.successfulOutcome == NULLP)
2464 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
2468 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
2469 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2470 e2apRicMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
2472 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2474 if(fillRicSubscriptionRsp(ricSubscriptionRsp, subsRspInfo) != ROK)
2476 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
2480 /* Prints the Msg formed */
2481 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
2483 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2485 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
2486 if(encRetVal.encoded == ENCODE_FAIL)
2488 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
2489 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2494 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
2495 #ifdef DEBUG_ASN_PRINT
2496 for(int i=0; i< encBufSize; i++)
2498 printf("%x",encBuf[i]);
2503 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2505 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
2514 FreeRicSubscriptionRsp(e2apRicMsg);
2518 /******************************************************************
2520 * @brief Deallocation of memory allocated by aper decoder for e2 setup response
2524 * Function : freeAperDecodingOfE2SetupRsp
2526 * Functionality: Deallocation of memory allocated by aper decoder for e2
2529 * @params[in] E2setupResponse_t *e2SetRspMsg;
2532 * ****************************************************************/
2533 void freeAperDecodingOfE2SetupRsp(E2setupResponse_t *e2SetRspMsg)
2535 uint8_t arrIdx, e2NodeConfigAddAckListIdx;
2536 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
2537 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAddAckList;
2541 if(e2SetRspMsg->protocolIEs.list.array)
2543 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2545 if(e2SetRspMsg->protocolIEs.list.array[arrIdx])
2547 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2549 case ProtocolIE_IDE2_id_TransactionID:
2552 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2554 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.pLMN_Identity.buf);
2555 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID.buf);
2559 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2561 e2NodeConfigAddAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2562 if(e2NodeConfigAddAckList->list.array )
2564 for(e2NodeConfigAddAckListIdx = 0; e2NodeConfigAddAckListIdx< e2NodeConfigAddAckList->list.count; e2NodeConfigAddAckListIdx++)
2566 if(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx])
2568 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx];
2569 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2570 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf);
2571 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2572 e2nodeComponentInterfaceTypeF1);
2573 free(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx]);
2576 free(e2NodeConfigAddAckList->list.array);
2581 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]);
2584 free(e2SetRspMsg->protocolIEs.list.array);
2589 /******************************************************************
2591 * @brief handling of e2 noe config update ack ies
2595 * Function :handleE2NodeConfigUpdateAckIes
2597 * Functionality: handling of e2 noe config update ack ies
2600 * Pointer to the E2 Node cfg
2603 ******************************************************************/
2605 void handleE2NodeConfigUpdateAckIes(PTR e2NodeCfg, uint8_t procedureCode)
2607 CmLList *node=NULLP;
2608 E2NodeComponent *e2NodeComponentInfo=NULLP;
2609 E2nodeComponentID_t *e2nodeComponentID=NULLP;
2610 E2nodeComponentConfigRemovalAck_Item_t *removalAckItem=NULLP;
2611 E2nodeComponentConfigUpdateAck_Item_t *updateAckItem=NULLP;
2612 E2nodeComponentConfigAdditionAck_Item_t *additionAckItem=NULLP;
2614 switch(procedureCode)
2616 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2618 additionAckItem = (E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg;
2619 e2nodeComponentID = &additionAckItem->e2nodeComponentID;
2622 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
2624 updateAckItem = (E2nodeComponentConfigUpdateAck_Item_t*) e2NodeCfg;
2625 e2nodeComponentID = &updateAckItem->e2nodeComponentID;
2628 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
2630 removalAckItem= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
2631 e2nodeComponentID = &removalAckItem->e2nodeComponentID;
2636 switch(e2nodeComponentID->present)
2638 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
2640 e2NodeComponentInfo = fetchE2NodeComponentInfo(F1, e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0], &node);
2641 if(!e2NodeComponentInfo)
2643 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
2652 switch(procedureCode)
2654 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2656 DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, e2NodeComponentInfo->addConfiguration->reqBufSize);
2657 DU_FREE(e2NodeComponentInfo->addConfiguration->componentResponsePart, e2NodeComponentInfo->addConfiguration->rspBufSize);
2658 DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
2661 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
2663 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentRequestPart, e2NodeComponentInfo->updateConfiguration->reqBufSize);
2664 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentResponsePart, e2NodeComponentInfo->updateConfiguration->rspBufSize);
2665 DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
2668 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
2670 cmLListDelFrm(&duCb.e2apDb.e2NodeComponentList, node);
2671 if(e2NodeComponentInfo->addConfiguration)
2673 DU_FREE(e2NodeComponentInfo->addConfiguration->componentRequestPart, e2NodeComponentInfo->addConfiguration->reqBufSize);
2674 DU_FREE(e2NodeComponentInfo->addConfiguration->componentResponsePart, e2NodeComponentInfo->addConfiguration->rspBufSize);
2675 DU_FREE(e2NodeComponentInfo->addConfiguration, sizeof(E2NodeConfig));
2677 if(e2NodeComponentInfo->updateConfiguration)
2679 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentRequestPart, e2NodeComponentInfo->updateConfiguration->reqBufSize);
2680 DU_FREE(e2NodeComponentInfo->updateConfiguration->componentResponsePart, e2NodeComponentInfo->updateConfiguration->rspBufSize);
2681 DU_FREE(e2NodeComponentInfo->updateConfiguration, sizeof(E2NodeConfig));
2683 DU_FREE(node, sizeof(CmLList));
2689 /******************************************************************
2691 * @brief Processes E2 Setup Response sent by RIC
2695 * Function : procE2SetupRsp
2697 * Functionality: Processes E2 Setup Response sent by RIC
2699 * @params[in] E2AP_PDU_t ASN decoded E2AP message
2702 * ****************************************************************/
2704 void procE2SetupRsp(E2AP_PDU_t *e2apMsg)
2706 bool invalidTransId = false;
2707 uint8_t arrIdx =0, transId=0, idx=0;
2708 uint32_t recvBufLen;
2709 E2setupResponse_t *e2SetRspMsg=NULL;
2710 E2nodeComponentConfigAdditionAck_List_t *e2NodeCfgAckList=NULL;
2711 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem=NULL;
2713 DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
2714 duCb.e2Status = TRUE; //Set E2 status as true
2715 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
2717 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2719 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2721 case ProtocolIE_IDE2_id_TransactionID:
2723 transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2724 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
2725 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
2727 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
2731 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
2732 invalidTransId = true;
2737 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2739 /* To store the Ric Id Params */
2740 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value\
2741 .choice.GlobalRIC_ID.pLMN_Identity.size);
2742 memcpy(&duCb.e2apDb.ricId.plmnId, e2SetRspMsg->protocolIEs.list.array[arrIdx]\
2743 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
2744 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID, &duCb.e2apDb.ricId);
2745 /*TODO : duCb.e2apDb.ricId.plmnId memory to be deallocated after the usage */
2749 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2751 e2NodeCfgAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2752 for(idx =0; idx <e2NodeCfgAckList->list.count; idx++)
2754 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeCfgAckList->list.array[idx];
2755 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
2756 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
2763 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
2764 e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
2769 if(invalidTransId == true)
2774 freeAperDecodingOfE2SetupRsp(e2SetRspMsg);
2776 if(invalidTransId == false)
2778 if(duSendE2NodeConfigurationUpdate() != ROK)
2780 DU_LOG("\nERROR --> E2AP : Failed to send E2 node config update");
2785 /*******************************************************************
2787 * @brief Free RIC Subscription Request
2791 * Function : freeAperDecodingOfRicSubsReq
2793 * Functionality : Free RIC Subscription Request
2797 ******************************************************************/
2798 void freeAperDecodingOfRicSubsReq(RICsubscriptionRequest_t *ricSubscriptionReq)
2801 uint8_t elementIdx = 0;
2802 RICsubscriptionDetails_t *subsDetails = NULLP;
2803 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
2805 if(ricSubscriptionReq->protocolIEs.list.array)
2807 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
2809 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
2811 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
2813 subsDetails = &(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails);
2814 free(subsDetails->ricEventTriggerDefinition.buf);
2816 if(subsDetails->ricAction_ToBeSetup_List.list.array)
2818 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
2820 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
2822 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
2823 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
2825 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf);
2826 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition);
2828 free(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]);
2831 free(subsDetails->ricAction_ToBeSetup_List.list.array);
2836 free(ricSubscriptionReq->protocolIEs.list.array[idx]);
2838 free(ricSubscriptionReq->protocolIEs.list.array);
2842 /*******************************************************************
2844 * @brief Free Event Trigger Definition
2848 * Function : freeAperDecodingOfEventTriggerDef
2850 * Functionality: Free Event Trigger Definition
2852 * @params[in] E2SM-KPM Event Trigger Definition
2855 * ****************************************************************/
2856 void freeAperDecodingOfEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
2860 switch(eventTiggerDef->eventDefinition_formats.present)
2862 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
2865 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
2866 free(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1);
2872 /*******************************************************************
2874 * @brief Extract E2SM-KPM Event trigger definition
2878 * Function : extractEventTriggerDef
2880 * Functionality : This function :
2881 * - Decodes E2SM-KPM Event Trigger Definition
2882 * - Validates that even trigger style is supported by E2 node
2883 * - Stores event trigger details in local DB
2885 * @params[in] RAN Function Database structure
2886 * RIC Subscription Info to be added to RAN function
2887 * RIC Event Trigger Definition buffer received from RIC
2888 * @return ROK - success
2891 ******************************************************************/
2892 uint8_t extractEventTriggerDef(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
2893 RICeventTriggerDefinition_t *ricEventTriggerDef, E2FailureCause *failureCause)
2895 uint8_t ret = RFAILED;
2896 uint8_t eventIdx = 0;
2897 asn_dec_rval_t rval ={0};
2898 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef, *eventTiggerDefPtr = NULLP;
2900 /* Decoding E2SM-KPM Even Trigger Definition */
2901 eventTiggerDefPtr = &eventTiggerDef;
2902 memset(eventTiggerDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
2904 rval = aper_decode(0, &asn_DEF_E2SM_KPM_EventTriggerDefinition, (void **)&eventTiggerDefPtr, ricEventTriggerDef->buf,\
2905 ricEventTriggerDef->size, 0, 0);
2906 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2908 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Event Trigger Definition");
2909 failureCause->causeType = E2_PROTOCOL;
2910 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
2914 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, eventTiggerDefPtr);
2916 /* Validating the received event trigger definition format */
2917 for(eventIdx = 0; eventIdx < ranFuncDb->numOfEventTriggerStyleSupported; eventIdx++)
2919 if((eventTiggerDefPtr->eventDefinition_formats.present != \
2920 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING) && \
2921 (eventTiggerDefPtr->eventDefinition_formats.present == ranFuncDb->eventTriggerStyleList[eventIdx].formatType))
2923 ricSubscriptionInfo->eventTriggerDefinition.formatType = ranFuncDb->eventTriggerStyleList[eventIdx].formatType;
2924 ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod = \
2925 eventTiggerDefPtr->eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod;
2934 failureCause->causeType = E2_RIC_REQUEST;
2935 failureCause->cause = E2_EVENT_TRIGGER_NOT_SUPPORTED;
2937 /* Free E2SM_KPM_EventTriggerDefinition_t */
2938 freeAperDecodingOfEventTriggerDef(eventTiggerDefPtr);
2942 /*******************************************************************
2944 * @brief Free RIC Action Definition
2948 * Function : freeAperDecodingOfRicActionDefinition
2950 * Functionality: Free RIC Action Definition
2952 * @params[in] E2SM-KPM Action definition
2955 * ****************************************************************/
2956 void freeAperDecodingOfRicActionDefinition(E2SM_KPM_ActionDefinition_t *actionDef)
2958 uint8_t elementIdx = 0;
2959 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
2960 MeasurementInfoItem_t *measItem = NULLP;
2962 switch(actionDef->actionDefinition_formats.present)
2964 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
2966 if(actionDef->actionDefinition_formats.choice.actionDefinition_Format1)
2968 actionFormat1 = actionDef->actionDefinition_formats.choice.actionDefinition_Format1;
2969 if(actionFormat1->measInfoList.list.array)
2971 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
2973 if(actionFormat1->measInfoList.list.array[elementIdx])
2975 measItem = actionFormat1->measInfoList.list.array[elementIdx];
2976 switch(measItem->measType.present)
2978 case MeasurementType_PR_NOTHING:
2981 case MeasurementType_PR_measName:
2983 free(measItem->measType.choice.measName.buf);
2987 case MeasurementType_PR_measID:
2993 free(actionFormat1->measInfoList.list.array);
2995 free(actionFormat1);
2999 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
3000 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
3001 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
3002 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
3008 /*******************************************************************
3010 * @brief Extract Measurement Info list from action definition
3014 * Function : extractMeasInfoList
3016 * Functionality : This function :
3017 * - Traverses Measurement-to-be-subscribed list
3018 * - Validates that each measurement in Measurement-to-be-subscribed
3019 * list is supported in RAN-Function->Measurement-supported list.
3020 * - If all measurements in an action is supported by RAN function,
3021 * it is added to measurement-subscribed list in local DB
3023 * @params[in] Measurement Info supported list by RAN function
3024 * Measurement Info to be subscribed as requested by RIC
3025 * Measurement Info finally subscribed
3026 * Memory failure indicator
3027 * @return ROK - success
3030 ******************************************************************/
3031 uint8_t extractMeasInfoList(CmLListCp *measInfoSupportedList, MeasurementInfoList_t *measInfoToBeSubscribedList, \
3032 CmLListCp *measInfoSubscribedList, bool *memFailure)
3034 uint8_t elementIdx = 0;
3035 MeasurementInfoForAction *measInfoSupportedDb = NULLP;
3036 MeasurementInfo *measInfoSubscribedDb = NULLP;
3037 CmLList *supportedMeasNode = NULLP, *measToAddNode = NULLP;
3038 MeasurementInfoItem_t *measItem = NULLP;
3040 /* Validate Measurement list is supported by E2 node.
3042 * Traverse and compare the Measurement-Supported List in E2
3043 * node with Measurement-to-be-subscribed list received from RIC.
3044 * If a match is found, add it to measurement-subscription list.
3046 for(elementIdx = 0; elementIdx < measInfoToBeSubscribedList->list.count; elementIdx++)
3048 measInfoSubscribedDb = NULLP;
3049 measToAddNode = NULLP;
3050 measItem = measInfoToBeSubscribedList->list.array[elementIdx];
3052 CM_LLIST_FIRST_NODE(measInfoSupportedList, supportedMeasNode);
3053 while(supportedMeasNode)
3055 measInfoSupportedDb = (MeasurementInfoForAction*)supportedMeasNode->node;
3056 switch(measItem->measType.present)
3058 case MeasurementType_PR_measName:
3060 if(!strcmp(measInfoSupportedDb->measurementTypeName, (char *)measItem->measType.choice.measName.buf))
3062 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
3067 case MeasurementType_PR_measID:
3069 if(measInfoSupportedDb->measurementTypeId == measItem->measType.choice.measID)
3071 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
3078 DU_LOG("\nERROR -> DUAPP: Invalid Measurement-type identifier in \
3079 E2SM-KPM Action Definition Format");
3082 } /* End of switch, for measurement type identifier */
3084 /* If measurement type is supported, add to measurement-subscription list */
3085 if(measInfoSubscribedDb)
3087 measInfoSubscribedDb->measurementTypeId = measInfoSupportedDb->measurementTypeId;
3088 memcpy(measInfoSubscribedDb->measurementTypeName, measInfoSupportedDb->measurementTypeName, \
3089 strlen(measInfoSupportedDb->measurementTypeName));
3091 DU_ALLOC(measToAddNode, sizeof(CmLList));
3094 measToAddNode->node = (PTR) measInfoSubscribedDb;
3095 cmLListAdd2Tail(measInfoSubscribedList, measToAddNode);
3097 /* Break out of while loop if measurement info is found in measurement-supported list */
3102 DU_FREE(measInfoSubscribedDb, sizeof(MeasurementInfo));
3103 measInfoSubscribedDb = NULLP;
3109 supportedMeasNode = supportedMeasNode->next;
3111 } /* End of while for traversing measurement-supported list in a report style */
3113 /* If a measurement-to-be-subscribed is not found in measurement-supported list in this report style
3115 * Delete all entries from measurement-subscription list and
3116 * Break out of for loop to search in next report style */
3117 if(!measInfoSubscribedDb)
3119 deleteMeasurementInfoList(measInfoSubscribedList);
3123 } /* End of for loop , traversing measurement-to-be-subscribed list */
3125 /* If all measurement-to-be-subscribed was found in measurement-supported list and
3126 * was added to measurement-subscription list successfully, return from here */
3127 if(measInfoToBeSubscribedList->list.count == measInfoSubscribedList->count)
3133 /*******************************************************************
3135 * @brief Extract E2SM-KPM Action definition
3139 * Function : extractRicActionDef
3141 * Functionality : This function :
3142 * - Decodes E2SM-KPM Action Definition
3143 * - Validates that action is supported by E2 node
3144 * - Stores action details in local DB
3146 * @params[in] RAN Function Database structure
3147 * RIC subscription's Action definition to be added to
3149 * RIC Action Definition buffer received from RIC
3150 * @return ROK - success
3153 ******************************************************************/
3154 uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefDb, RICactionDefinition_t *ricActionDef,\
3155 E2FailureCause *failureCause)
3157 bool memFailure = false;
3158 uint8_t styleIdx = 0;
3159 asn_dec_rval_t rval ={0};
3161 E2SM_KPM_ActionDefinition_t actionDef, *actionDefPtr = NULLP;
3162 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
3163 CmLListCp *measInfoSupportedList = NULLP;
3164 CmLListCp *measInfoSubscribedList = NULLP;
3166 /* Decoding E2SM-KPM Action Definition */
3167 actionDefPtr = &actionDef;
3168 memset(actionDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
3170 rval = aper_decode(0, &asn_DEF_E2SM_KPM_ActionDefinition, (void **)&actionDefPtr, ricActionDef->buf,\
3171 ricActionDef->size, 0, 0);
3172 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
3174 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Action Definition");
3175 failureCause->causeType = E2_PROTOCOL;
3176 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
3180 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDefPtr);
3183 /* Validate if Report style to subscribe is supported by E2 Node */
3184 for(styleIdx= 0; styleIdx < ranFuncDb->numOfReportStyleSupported; styleIdx++)
3186 /* Validate Report style type and report style format type is supported by E2 Node */
3187 if((ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType == actionDefPtr->ric_Style_Type) &&
3188 (ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType == actionDefPtr->actionDefinition_formats.present))
3190 /* Fetch Report stype type and format type */
3191 actionDefDb->styleType = actionDefPtr->ric_Style_Type;
3192 actionDefDb->formatType = actionDefPtr->actionDefinition_formats.present;
3194 switch(actionDefPtr->actionDefinition_formats.present)
3196 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
3198 actionFormat1 = actionDefPtr->actionDefinition_formats.choice.actionDefinition_Format1;
3200 /* Fetch granularity period */
3201 actionDefDb->choice.format1.granularityPeriod = actionFormat1->granulPeriod;
3203 /* Validate and add the Measurement to subscription list */
3204 measInfoSupportedList = &ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
3205 measInfoSubscribedList = &actionDefDb->choice.format1.measurementInfoList;
3206 if(extractMeasInfoList(measInfoSupportedList, &actionFormat1->measInfoList, \
3207 measInfoSubscribedList, &memFailure) == ROK)
3211 /* Free E2SM_KPM_ActionDefinition_t */
3212 freeAperDecodingOfRicActionDefinition(actionDefPtr);
3217 break; /* End of E2SM-KPM Action definition format 1 case */
3222 DU_LOG("\nERROR -> DUAPP: Only E2SM-KPM Action Definition Format 1 is supported");
3225 } /* End of switch for E2SM-KPM Action definition formats */
3230 failureCause->causeType = E2_MISCELLANEOUS;
3231 failureCause->cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3234 } /* End of for loop, traversing Report-styles-supported list in E2 node */
3236 /* Memset action Db and Free E2SM_KPM_ActionDefinition_t */
3237 memset(actionDefDb, 0, sizeof(ActionDefinition));
3238 freeAperDecodingOfRicActionDefinition(actionDefPtr);
3240 if(failureCause->causeType == E2_NOTHING)
3242 failureCause->causeType = E2_RIC_REQUEST;
3243 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3248 /*******************************************************************
3250 * @brief add RIC Subs action info
3254 * Function : addRicSubsAction
3256 * Functionality: add Ric Subs action info
3260 * Pointer to Ric Subc info
3261 * Action Sequence list
3264 * @return ROK - success
3267 ******************************************************************/
3269 CmLList *addRicSubsAction(RanFunction *ranFuncDb, PTR ricSubsInfo, CmLListCp *actionSequence, uint8_t procedureCode, E2FailureCause *failureCause)
3271 CmLList *actionNode = NULLP;
3272 ActionInfo *actionDb = NULLP;
3273 RICactionID_t ricActionID;
3274 RICactionType_t ricActionType;
3275 RICactionDefinition_t *ricActionDefinition= NULLP;
3276 RICaction_ToBeSetup_Item_t *setupItem= NULLP;
3277 RICaction_ToBeAddedForModification_Item_t *addIem= NULLP;
3278 RICaction_ToBeModifiedForModification_Item_t *modifiedItem= 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_RICaction_ToBeAddedForModification_Item:
3295 addIem = (RICaction_ToBeAddedForModification_Item_t*) ricSubsInfo;
3296 ricActionID= addIem->ricActionID;
3297 ricActionType= addIem->ricActionType;
3298 ricActionDefinition = &addIem->ricActionDefinition;
3302 case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item:
3304 modifiedItem= (RICaction_ToBeModifiedForModification_Item_t*)ricSubsInfo;
3305 ricActionID= modifiedItem->ricActionID;
3306 /* Added since ricActionType IE is not present in case of
3308 ricActionType = RICactionType_report;
3309 if(modifiedItem->ricActionDefinition)
3311 ricActionDefinition = modifiedItem->ricActionDefinition;
3318 DU_ALLOC(actionDb, sizeof(ActionInfo));
3321 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
3324 if(ricActionType== RICactionType_report)
3326 actionDb->actionId = ricActionID;
3327 actionDb->type = REPORT;
3329 if(extractRicActionDef(ranFuncDb, &actionDb->definition, ricActionDefinition, failureCause) == ROK)
3331 actionDb->action = CONFIG_ADD;
3334 DU_ALLOC(actionNode, sizeof(CmLList));
3337 actionNode->node = (PTR) actionDb;
3338 cmLListAdd2Tail(actionSequence, actionNode);
3342 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
3343 DU_FREE(actionDb, sizeof(ActionInfo));
3350 /*******************************************************************
3352 * @brief Extract RIC Action to be setup
3356 * Function : extractRicActionToBeSetup
3358 * Functionality : This function :
3359 * - Validates that each action-to-be-setup is supported by E2 node
3360 * - Stores event trigger details in local DB
3362 * @params[in] RAN Function Database structure
3363 * RIC Subscription Info to be added to RAN function
3364 * RIC Action To Be Setup List received from RIC
3365 * @return ROK - success
3368 ******************************************************************/
3369 uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
3370 RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause, PendingSubsRspInfo *subsRsp)
3372 CmLList *actionNode = NULLP;
3373 uint8_t actionIdx = 0;
3374 uint8_t ricActionId = 0;
3375 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
3377 if(actionList->list.array)
3379 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
3381 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)actionList->list.array[actionIdx];
3382 switch(actionItem->id)
3384 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
3386 /* If Action type is REPORT and
3387 * If RIC action definition's extraction and validation passes,
3389 * This action is added to action sequence list of subscription info */
3390 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeSetup_Item,\
3391 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item, failureCause);
3395 /* In case of any failure, action is rejected
3396 * Added to rejected-action-list in subscription response */
3397 subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId;
3398 if(failureCause->causeType == E2_NOTHING)
3400 failureCause->causeType = E2_RIC_REQUEST;
3401 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
3403 memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \
3404 failureCause, sizeof(E2FailureCause));
3405 subsRsp->numOfRejectedActions++;
3410 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
3416 /* If there is even 1 action that can be added, return ROK */
3417 if(ricSubscriptionInfo->actionSequence.count)
3420 if(failureCause->causeType == E2_NOTHING)
3422 failureCause->causeType = E2_RIC_REQUEST;
3423 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
3428 /******************************************************************
3430 * @brief Processes RIC Subscription Req sent by RIC
3434 * Function : procRicSubscriptionRequest
3436 * Functionality: Processes RIC Subscription Request from RIC
3438 * @params[in] E2AP_PDU_t ASN decoded E2AP message
3439 * @return ROK - success
3442 * ****************************************************************/
3443 uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg)
3447 uint16_t ranFuncId = 0;
3448 RicRequestId ricReqId;
3449 CmLList *ricSubscriptionNode = NULLP;
3450 RanFunction *ranFuncDb = NULLP;
3451 RICsubscriptionRequest_t *ricSubsReq = NULLP;
3452 RICsubscriptionDetails_t *subsDetails = NULLP;
3453 RicSubscription *ricSubscriptionInfo = NULLP;
3454 E2FailureCause failureCause;
3456 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
3458 memset(&failureCause, 0, sizeof(E2FailureCause));
3459 memset(&ricReqId, 0, sizeof(RicRequestId));
3461 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
3462 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
3464 if(ricSubsReq->protocolIEs.list.array[idx])
3466 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
3468 case ProtocolIE_IDE2_id_RICrequestID:
3470 ricReqId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID;
3471 ricReqId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID;
3476 case ProtocolIE_IDE2_id_RANfunctionID:
3478 ranFuncId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID;
3480 /* Validating RAN Function id */
3481 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
3485 failureCause.causeType = E2_RIC_REQUEST;
3486 failureCause.cause = E2_RAN_FUNCTION_ID_INVALID;
3491 if(ranFuncDb->numPendingSubsRsp >= MAX_PENDING_SUBSCRIPTION_RSP)
3493 failureCause.causeType = E2_RIC_REQUEST;
3494 failureCause.cause = E2_FUNCTION_RESOURCE_LIMIT;
3499 DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription));
3500 if(!ricSubscriptionInfo)
3502 DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
3503 failureCause.causeType = E2_MISCELLANEOUS;
3504 failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
3508 ricSubscriptionInfo->requestId.requestorId = ricReqId.requestorId;
3509 ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId;
3510 ricSubscriptionInfo->ranFuncId = ranFuncId;
3512 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3513 memcpy(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].requestId,
3514 &ricReqId, sizeof(RicRequestId));
3515 ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].ranFuncId = ranFuncId;
3519 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
3521 subsDetails = &ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails;
3523 /* Decode, Validate and record Event Trigger Definition */
3524 if(extractEventTriggerDef(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricEventTriggerDefinition, \
3525 &failureCause) != ROK)
3531 /* Decode, Validate and record RIC actions */
3532 if(extractRicActionToBeSetup(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricAction_ToBeSetup_List, \
3533 &failureCause, &ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp]) != ROK)
3542 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
3543 ricSubsReq->protocolIEs.list.array[idx]->id);
3552 freeAperDecodingOfRicSubsReq(ricSubsReq);
3556 cmInitTimers(&(ricSubscriptionInfo->ricSubsReportTimer), 1);
3557 ricSubscriptionInfo->action = CONFIG_ADD;
3559 /* Add RAN subcription detail to RAN function */
3560 DU_ALLOC(ricSubscriptionNode, sizeof(CmLList));
3561 if(ricSubscriptionNode)
3563 ricSubscriptionNode->node = (PTR) ricSubscriptionInfo;
3564 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubscriptionNode);
3567 ranFuncDb->numPendingSubsRsp++;
3569 #ifdef KPI_CALCULATION
3570 /* Send statistics request to other DU entities */
3571 BuildAndSendStatsReq(ricSubscriptionInfo);
3576 DU_FREE(ricSubscriptionInfo, sizeof(RicSubscription));
3580 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3583 /* Send RIC Subcription Failure */
3584 BuildAndSendRicSubscriptionFailure(ricReqId, ranFuncId, failureCause);
3589 /******************************************************************
3591 * @brief Free RIC Subscription Failure
3595 * Function : FreeRicSubscriptionFailure
3597 * Functionality: Free RIC Subscription Failure
3599 * @params[in] E2AP PDU
3602 * ****************************************************************/
3603 void FreeRicSubscriptionFailure(E2AP_PDU_t *e2apMsg)
3605 uint8_t elemIdx = 0;
3606 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3610 if(e2apMsg->choice.unsuccessfulOutcome)
3612 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3613 if(ricSubscriptionFailure->protocolIEs.list.array)
3615 for(elemIdx = 0; elemIdx < ricSubscriptionFailure->protocolIEs.list.count; elemIdx++)
3617 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3619 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3621 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3623 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3627 /******************************************************************
3629 * @brief Fill and Send RIC Subscription Failure to RIC
3633 * Function : BuildAndSendRicSubscriptionFailure
3635 * Functionality: Fill and Send RIC Subscription Failure to RIC
3637 * @params[in] RIC Request ID
3640 * @return ROK - success
3643 * ****************************************************************/
3644 uint8_t BuildAndSendRicSubscriptionFailure(RicRequestId ricReqId, uint16_t ranFuncId, E2FailureCause failureCause)
3646 uint8_t ret = RFAILED;
3647 uint8_t elementCnt = 0, elemIdx = 0;
3648 E2AP_PDU_t *e2apMsg = NULLP;
3649 asn_enc_rval_t encRetVal; /* Encoder return value */
3650 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3651 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3655 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Failure\n");
3657 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3658 if(e2apMsg == NULLP)
3660 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3664 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3665 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3666 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3668 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3671 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
3672 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3673 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure;
3675 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3678 ricSubscriptionFailure->protocolIEs.list.count = elementCnt;
3679 ricSubscriptionFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionFailure_IEs_t *);
3680 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3681 if(!ricSubscriptionFailure->protocolIEs.list.array)
3683 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3687 for(elemIdx = 0; elemIdx < elementCnt; elemIdx++)
3689 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3690 if(!ricSubscriptionFailure->protocolIEs.list.array[elemIdx])
3692 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d] for IE at index [%d]", \
3693 __func__, __LINE__, elemIdx);
3697 if(elemIdx < elementCnt)
3702 /* RIC Request ID */
3703 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3704 ricSubsFailIe->id = ProtocolIE_IDE2_id_RICrequestID;
3705 ricSubsFailIe->criticality = CriticalityE2_reject;
3706 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
3707 ricSubsFailIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3708 ricSubsFailIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3710 /* RAN Function ID */
3711 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3712 ricSubsFailIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3713 ricSubsFailIe->criticality = CriticalityE2_reject;
3714 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
3715 ricSubsFailIe->value.choice.RANfunctionID = ranFuncId;
3718 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3719 ricSubsFailIe->id = ProtocolIE_IDE2_id_CauseE2;
3720 ricSubsFailIe->criticality = CriticalityE2_reject;
3721 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_CauseE2;
3722 fillE2Cause(&ricSubsFailIe->value.choice.CauseE2, failureCause);
3724 /* Prints the Msg formed */
3725 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3726 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3728 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3729 if(encRetVal.encoded == ENCODE_FAIL)
3731 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Failure Message (at %s)\n",\
3732 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3737 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Failure Message \n");
3738 #ifdef DEBUG_ASN_PRINT
3739 for(int i=0; i< encBufSize; i++)
3741 printf("%x",encBuf[i]);
3746 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
3748 DU_LOG("\nINFO --> E2AP : Sending RIC Subscription Failure");
3754 FreeRicSubscriptionFailure(e2apMsg);
3758 /*******************************************************************
3760 * @brief Free the RicIndication Message
3764 * Function : FreeRicIndication
3766 * Functionality: Free the RicIndication Message
3771 ******************************************************************/
3772 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
3775 RICindication_t *ricIndicationMsg= NULLP;
3777 if(e2apMsg != NULLP)
3779 if(e2apMsg->choice.initiatingMessage != NULLP)
3781 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
3782 if(ricIndicationMsg!= NULLP)
3784 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
3786 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
3788 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
3790 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
3792 case ProtocolIE_IDE2_id_RICrequestID:
3793 case ProtocolIE_IDE2_id_RANfunctionID:
3794 case ProtocolIE_IDE2_id_RICactionID:
3795 case ProtocolIE_IDE2_id_RICindicationType:
3798 case ProtocolIE_IDE2_id_RICindicationHeader:
3800 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
3801 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
3804 case ProtocolIE_IDE2_id_RICindicationMessage:
3806 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
3807 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
3813 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
3816 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
3819 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3821 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3825 /*******************************************************************
3827 * @brief Free measurement record
3831 * Function : freeMeasRecord
3833 * Functionality: Free all measurement recorded for a measurement
3834 * within an action in a RIC subscription
3836 * @param Measurement data to be freed
3839 ******************************************************************/
3840 void freeMeasData(MeasurementData_t *measData)
3842 uint8_t measIdx = 0, measRecIdx = 0;
3843 MeasurementRecord_t *measRecord = NULLP;
3845 if(measData->list.array)
3847 for(measIdx = 0; measIdx < measData->list.count; measIdx++)
3849 if(measData->list.array[measIdx])
3851 measRecord = &measData->list.array[measIdx]->measRecord;
3852 if(measRecord->list.array)
3854 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3856 DU_FREE(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3858 DU_FREE(measRecord->list.array, measRecord->list.size);
3860 DU_FREE(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
3863 DU_FREE(measData->list.array, measData->list.size);
3867 /*******************************************************************
3869 * @brief Fill measurement info list
3873 * Function : freeMeasInfoList
3875 * Functionality: Fills all measurement info within an action
3876 * in a RIC subscription
3878 * @param Measurement Info list to be freed
3881 ******************************************************************/
3882 void freeMeasInfoList(MeasurementInfoList_t *measInfoList)
3884 uint8_t measInfoIdx = 0;
3886 if(measInfoList->list.array)
3888 for(measInfoIdx = 0; measInfoIdx < measInfoList->list.count; measInfoIdx++)
3890 if(measInfoList->list.array[measInfoIdx])
3892 DU_FREE(measInfoList->list.array[measInfoIdx]->measType.choice.measName.buf, \
3893 measInfoList->list.array[measInfoIdx]->measType.choice.measName.size);
3895 DU_FREE(measInfoList->list.array[measInfoIdx], measInfoList->list.size);
3898 DU_FREE(measInfoList->list.array, measInfoList->list.size);
3902 /*******************************************************************
3904 * @brief Free E2SM-KPM Indication Message
3908 * Function : FreeE2smKpmIndicationMessage
3910 * Functionality: Free E2SM-KPM Indication Message
3912 * @param E2SM-KPM Indication message to be freed
3915 ******************************************************************/
3916 void FreeE2smKpmIndicationMessage(E2SM_KPM_IndicationMessage_t *e2smKpmIndMsg)
3918 E2SM_KPM_IndicationMessage_Format1_t *format1Msg = NULLP;
3920 switch(e2smKpmIndMsg->indicationMessage_formats.present)
3922 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
3924 if(e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1)
3926 format1Msg = e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1;
3928 /* Measurement Data */
3929 freeMeasData(&format1Msg->measData);
3931 /* Measurement Info List */
3932 if(format1Msg->measInfoList)
3934 freeMeasInfoList(format1Msg->measInfoList);
3935 DU_FREE(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
3938 /* Granularity Period */
3939 DU_FREE(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
3941 DU_FREE(format1Msg, sizeof(E2SM_KPM_IndicationMessage_Format1_t));
3946 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
3947 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
3953 /*******************************************************************
3955 * @brief Fill measurement record
3959 * Function : fillMeasRecord
3961 * Functionality: Fills all measurement value for a measurement
3962 * within an action in a RIC subscription
3964 * @param Measurement record to be filled
3965 * Measurement database with measurement records
3966 * @return ROK - success
3969 ******************************************************************/
3970 uint8_t fillMeasRecord(MeasurementRecord_t *measRecord, MeasurementInfo *measInfoDb)
3972 uint8_t measRecIdx = 0;
3973 CmLList *measValNode = NULLP;
3976 measRecord->list.count = measInfoDb->measuredValue.count;
3977 measRecord->list.size = measRecord->list.count * sizeof(MeasurementRecordItem_t *);
3979 DU_ALLOC(measRecord->list.array, measRecord->list.size);
3980 if(!measRecord->list.array)
3982 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3986 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3988 DU_ALLOC(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3989 if(!measRecord->list.array[measRecIdx])
3991 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3997 CM_LLIST_FIRST_NODE(&measInfoDb->measuredValue, measValNode);
4000 measVal = *(double *)measValNode->node;
4001 if(measVal == (int)measVal)
4003 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_integer;
4004 measRecord->list.array[measRecIdx]->choice.integer = (int)measVal;
4008 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_real;
4009 measRecord->list.array[measRecIdx]->choice.real = measVal;
4012 measValNode= measValNode->next;
4013 /* Once the measurement record is added to the message, delete it from DB */
4016 deleteMeasuredValueList(&measInfoDb->measuredValue);
4020 /*******************************************************************
4022 * @brief Fills measuerement data
4026 * Function : fillMeasData
4028 * Functionality: Fill all measurement recorded for all measurements
4029 * in an action in a RIC subscription
4031 * @param Measurement data to be filled
4032 * Measurement info list from an action DB
4033 * @return ROK - success
4036 ******************************************************************/
4037 uint8_t fillMeasData(MeasurementData_t *measData, CmLListCp *measInfoListDb)
4039 uint8_t measIdx = 0;
4040 CmLList *measInfoNode = NULLP;
4041 MeasurementInfo *measInfoDb = NULLP;
4042 MeasurementRecord_t *measRecord = NULLP;
4044 measData->list.count = measInfoListDb->count;
4045 measData->list.size = measData->list.count * sizeof(MeasurementDataItem_t *);
4047 DU_ALLOC(measData->list.array, measData->list.size);
4048 if(!measData->list.array)
4050 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4055 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4058 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4061 DU_ALLOC(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
4062 if(!measData->list.array[measIdx])
4064 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4068 measRecord = &measData->list.array[measIdx]->measRecord;
4069 if(fillMeasRecord(measRecord, measInfoDb) != ROK)
4071 DU_LOG("\nERROR --> E2AP : Failed to fill measurement record");
4076 measInfoNode = measInfoNode->next;
4082 /*******************************************************************
4084 * @brief Fill all measurement info
4088 * Function : fillMeasInfoList
4090 * Functionality: Fills all measurement info belonging to an action
4091 * in a RIC subscription
4093 * @param Measurement Info list to be filled
4094 * Measurement Info list from E2AP DB
4095 * @return ROK - success
4098 ******************************************************************/
4099 uint8_t fillMeasInfoList(MeasurementInfoList_t *measInfoList, CmLListCp *measInfoListDb)
4101 uint8_t measInfoIdx = 0;
4102 CmLList *measInfoNode = NULLP;
4103 MeasurementInfo *measInfoDb = NULLP;
4104 MeasurementInfoItem_t *measInfoItem = NULLP;
4106 measInfoList->list.count = measInfoListDb->count;
4107 measInfoList->list.size = measInfoList->list.count * sizeof(MeasurementInfoItem_t *);
4109 DU_ALLOC(measInfoList->list.array, measInfoList->list.size);
4110 if(!measInfoList->list.array)
4112 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4117 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
4120 DU_ALLOC(measInfoList->list.array[measInfoIdx], sizeof(MeasurementInfoItem_t));
4121 if(!measInfoList->list.array[measInfoIdx])
4123 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4127 measInfoItem = measInfoList->list.array[measInfoIdx];
4128 measInfoDb = (MeasurementInfo *)measInfoNode->node;
4131 /* Measurement Type */
4132 measInfoItem->measType.present = MeasurementType_PR_measName;
4133 measInfoItem->measType.choice.measName.size = strlen(measInfoDb->measurementTypeName);
4135 DU_ALLOC(measInfoItem->measType.choice.measName.buf, measInfoItem->measType.choice.measName.size);
4136 if(!measInfoItem->measType.choice.measName.buf)
4138 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4142 memcpy(measInfoItem->measType.choice.measName.buf, measInfoDb->measurementTypeName,\
4143 measInfoItem->measType.choice.measName.size);
4147 measInfoNode = measInfoNode->next;
4154 /*******************************************************************
4156 * @brief Fill E2SM-KPM Indication Message Format 1
4160 * Function : fillE2smKpmIndMsgFormat1
4162 * Functionality: Fill E2SM-KPM Indication Message Format 1
4164 * @param Format 1 Message to be filled
4165 * Action Definition format 1 from E2AP DB
4166 * @return ROK - success
4169 ******************************************************************/
4170 uint8_t fillE2smKpmIndMsgFormat1(E2SM_KPM_IndicationMessage_Format1_t *format1Msg, ActionDefFormat1 *format1)
4172 /* Measurement Data */
4173 if(fillMeasData(&format1Msg->measData, &format1->measurementInfoList) != ROK)
4175 DU_LOG("\nERROR --> E2AP : Failed to fill measurement data");
4179 /* Measurement Information */
4180 DU_ALLOC(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
4181 if(!format1Msg->measInfoList)
4183 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4187 if(fillMeasInfoList(format1Msg->measInfoList, &format1->measurementInfoList) != ROK)
4189 DU_LOG("\nERROR --> E2AP : Failed to fill measurement information list");
4193 /* Granularity Period */
4194 DU_ALLOC(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
4195 if(!format1Msg->granulPeriod)
4197 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4200 *(format1Msg->granulPeriod) = format1->granularityPeriod;
4205 /*******************************************************************
4207 * @brief Fill RIC Indication Message buffer
4211 * Function : fillRicIndMsgBuf
4213 * Functionality: Fill E2SM-KPM Indication Message
4214 * Encode this message and copy to RIC Indication Message buffer
4216 * @param RIC Indication Message buffer to be filled
4217 * Source action info from E2AP DB
4218 * @return ROK - success
4221 ******************************************************************/
4222 uint8_t fillRicIndMsgBuf(RICindicationMessage_t *ricIndMsgBuf, ActionInfo *actionInfo)
4224 uint8_t ret = RFAILED;
4225 bool failedInFormat = false;
4226 E2SM_KPM_IndicationMessage_t e2smKpmIndMsg;
4227 asn_enc_rval_t encRetVal; /* Encoder return value */
4229 memset(&e2smKpmIndMsg, 0, sizeof(E2SM_KPM_IndicationMessage_t));
4233 /* E2SM-KPM Indication message format type */
4234 e2smKpmIndMsg.indicationMessage_formats.present = actionInfo->definition.formatType;
4235 switch(e2smKpmIndMsg.indicationMessage_formats.present)
4237 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
4239 /* E2SM-KPM Indication message format 1 */
4240 DU_ALLOC(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4241 sizeof(E2SM_KPM_IndicationMessage_Format1_t));
4242 if(!e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1)
4244 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4245 failedInFormat = true;
4249 if(fillE2smKpmIndMsgFormat1(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
4250 &actionInfo->definition.choice.format1) != ROK)
4252 DU_LOG("\nERROR --> E2AP : Failed to fill E2SM-KPM Indication message format 1");
4253 failedInFormat = true;
4259 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
4260 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
4263 DU_LOG("\nERROR --> E2AP : fillRicIndMsgBuf: Only Format 1 supported");
4264 failedInFormat = true;
4272 /* Encode E2SM-KPM Indication Message */
4273 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationMessage, &e2smKpmIndMsg);
4274 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4276 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationMessage, 0, &e2smKpmIndMsg, PrepFinalEncBuf, encBuf);
4277 if(encRetVal.encoded == ENCODE_FAIL)
4279 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Message (at %s)\n",\
4280 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4285 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Message \n");
4286 #ifdef DEBUG_ASN_PRINT
4287 for(int i=0; i< encBufSize; i++)
4289 printf("%x",encBuf[i]);
4294 /* Copy encoded string to RIC Indication Message buffer */
4295 ricIndMsgBuf->size = encBufSize;
4296 DU_ALLOC(ricIndMsgBuf->buf, ricIndMsgBuf->size);
4297 if(!ricIndMsgBuf->buf)
4299 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4302 memset(ricIndMsgBuf->buf, 0, ricIndMsgBuf->size);
4303 memcpy(ricIndMsgBuf->buf, encBuf, encBufSize);
4309 /* Free E2SM-KPM Indication Message */
4310 FreeE2smKpmIndicationMessage(&e2smKpmIndMsg);
4315 /*******************************************************************
4317 * @brief Free E2SM-KPM Indication Header
4321 * Function : FreeE2smKpmIndicationHeader
4323 * Functionality: Free E2SM-KPM Indication Header
4325 * @param E2SM-KPM Indication Header to be free
4328 ******************************************************************/
4329 void FreeE2smKpmIndicationHeader(E2SM_KPM_IndicationHeader_t *e2smKpmIndHdr)
4331 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4335 switch(e2smKpmIndHdr->indicationHeader_formats.present)
4337 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4339 if(e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1)
4341 format1 = e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1;
4343 DU_FREE(format1->colletStartTime.buf, format1->colletStartTime.size);
4344 DU_FREE(format1, sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4348 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4355 /*******************************************************************
4357 * @brief Fill RIC Indication Header buffer
4361 * Function : fillRicIndHeader
4363 * Functionality: Fill E2SM-KPM Indication Header
4364 * Encode this message and copy to RIC Indication Header buffer
4366 * @param RIC Indication Header buffer to be filled
4367 * Source RIC subscription info from E2AP DB
4368 * @return ROK - success
4371 ******************************************************************/
4372 uint8_t fillRicIndHeader(RICindicationHeader_t *ricIndHdr, RicSubscription *ricSubsInfo)
4374 uint8_t ret = RFAILED;
4375 uint8_t secBufIdx = 0, milliSecBufIdx = 0;
4377 bool formatFailure = false;
4378 RanFunction *ranFunc = NULLP;
4379 ReportStartTime *startTime = NULLP;
4380 E2SM_KPM_IndicationHeader_t e2smKpmIndHdr;
4381 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
4382 asn_enc_rval_t encRetVal; /* Encoder return value */
4386 ranFunc = fetchRanFuncFromRanFuncId(ricSubsInfo->ranFuncId);
4387 if(ranFunc == NULLP)
4389 DU_LOG("\nERROR --> E2AP : RAN Function ID [%d] not found", ricSubsInfo->ranFuncId);
4393 memset(&e2smKpmIndHdr, 0, sizeof(E2SM_KPM_IndicationHeader_t));
4395 e2smKpmIndHdr.indicationHeader_formats.present = ranFunc->ricIndicationHeaderFormat;
4396 switch(e2smKpmIndHdr.indicationHeader_formats.present)
4398 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
4400 DU_ALLOC(e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1, \
4401 sizeof(E2SM_KPM_IndicationHeader_Format1_t));
4402 if(!e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1)
4404 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4405 formatFailure = true;
4408 format1 = e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1;
4410 /* Fetch reporting period start time from DB */
4411 switch(ricSubsInfo->eventTriggerDefinition.formatType)
4415 startTime = &ricSubsInfo->eventTriggerDefinition.choice.format1.startTime;
4419 format1->colletStartTime.size = 8 * sizeof(uint8_t);
4420 DU_ALLOC(format1->colletStartTime.buf, format1->colletStartTime.size);
4421 if(!format1->colletStartTime.buf)
4423 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4424 formatFailure = true;
4428 /* As per O-RAN.WG3.E2SM-KPM-R003-v03.00, section 8.3.12 and
4429 * RFC 5905, section 6 :
4430 * Time stamp has a 64-bit format where first 32-bit is seconds
4431 * and next 32-bit is fraction in picosecond-level.
4432 * This fraction has been rounded in microseconds.
4435 * Storing 32-bit seconds at MSB 0-3 and
4436 * 32-bit milliseconds at next 4 bytes i.e. bytes 4-7
4440 for(byteIdx = 3; byteIdx >= 0; byteIdx--)
4442 format1->colletStartTime.buf[secBufIdx++] = startTime->timeInSec >> (8*byteIdx);
4443 format1->colletStartTime.buf[milliSecBufIdx++] = startTime->timeInMilliSec >> (8*byteIdx);
4448 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
4451 DU_LOG("\nERROR --> E2AP : Only E2SM-KPM Indication Header Format 1 supported");
4452 formatFailure = true;
4460 /* Encode E2SM-KPM Indication Header */
4461 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationHeader, &e2smKpmIndHdr);
4462 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4464 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationHeader, 0, &e2smKpmIndHdr, PrepFinalEncBuf, encBuf);
4465 if(encRetVal.encoded == ENCODE_FAIL)
4467 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Header (at %s)\n",\
4468 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4473 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Header \n");
4474 #ifdef DEBUG_ASN_PRINT
4475 for(int i=0; i< encBufSize; i++)
4477 printf("%x",encBuf[i]);
4482 /* Copy encoded string to RIC Indication Header buffer */
4483 ricIndHdr->size = encBufSize;
4484 DU_ALLOC(ricIndHdr->buf, ricIndHdr->size);
4487 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4490 memset(ricIndHdr->buf, 0, ricIndHdr->size);
4491 memcpy(ricIndHdr->buf, encBuf, encBufSize);
4496 /* Free E2SM-KPM Indication Header */
4497 FreeE2smKpmIndicationHeader(&e2smKpmIndHdr);
4502 /*******************************************************************
4504 * brief Fill the RIC Indication Message
4508 * Function : fillRicIndication
4510 * Functionality: Fills the RIC Indication Message
4512 * @param RIC Indication Message to be filled
4513 * RIC Subscription DB
4515 * @return ROK - success
4518 ******************************************************************/
4519 uint8_t fillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4521 uint8_t elementCnt = 0, idx = 0;
4526 ricIndicationMsg->protocolIEs.list.count = elementCnt;
4527 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_IEs_t *);
4529 /* Initialize the Ric Indication members */
4530 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, ricIndicationMsg->protocolIEs.list.size);
4531 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
4533 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4537 for(idx=0; idx<elementCnt; idx++)
4539 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx], sizeof(RICindication_IEs_t));
4540 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
4542 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
4547 /* RIC Request ID */
4549 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
4550 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4551 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICrequestID;
4552 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = \
4553 ricSubscriptionInfo->requestId.requestorId;
4554 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = \
4555 ricSubscriptionInfo->requestId.instanceId;
4557 /* RAN Function ID */
4559 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
4560 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4561 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RANfunctionID;
4562 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ricSubscriptionInfo->ranFuncId;
4566 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
4567 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4568 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICactionID;
4569 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = actionInfo->actionId;
4571 /* RIC Indication Type */
4573 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
4574 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4575 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationType;
4576 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = actionInfo->type;
4578 /* RIC Indication Header */
4580 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
4581 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4582 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationHeader;
4583 if(fillRicIndHeader(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader, \
4584 ricSubscriptionInfo) != ROK)
4586 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication header");
4590 /* RIC Indication Message */
4592 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
4593 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4594 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationMessage;
4595 if(fillRicIndMsgBuf(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage, \
4598 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication Message");
4605 /*******************************************************************
4607 * @brief Builds and Send the RicIndication Message
4611 * Function : BuildAndSendRicIndication
4613 * Functionality:Fills the RicIndication Message
4615 * @return ROK - success
4618 ******************************************************************/
4620 uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4622 uint8_t ret = RFAILED;
4623 E2AP_PDU_t *e2apMsg = NULLP;
4624 RICindication_t *ricIndicationMsg = NULLP;
4625 asn_enc_rval_t encRetVal; /* Encoder return value */
4629 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
4631 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4632 if(e2apMsg == NULLP)
4634 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4638 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4639 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4640 if(e2apMsg->choice.initiatingMessage == NULLP)
4642 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4645 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
4646 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4647 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
4649 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
4651 if(fillRicIndication(ricIndicationMsg, ricSubscriptionInfo, actionInfo) != ROK)
4653 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication message");
4657 /* Prints the Msg formed */
4658 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4659 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4661 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4663 if(encRetVal.encoded == ENCODE_FAIL)
4665 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
4666 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4671 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
4672 #ifdef DEBUG_ASN_PRINT
4673 for(int i=0; i< encBufSize; i++)
4675 printf("%x",encBuf[i]);
4680 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
4682 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
4688 FreeRicIndication(e2apMsg);
4692 /*******************************************************************
4694 * @brief free e2 node component configuration req and rsp
4698 * Function : freeE2NodeComponentConfiguration
4701 * - free e2 node component configuration req and rsp
4703 * @params[in] E2nodeComponentConfiguration_t *e2nodeComponentConfiguration
4704 * @return ROK - success
4707 * ****************************************************************/
4709 void freeE2NodeComponentConfiguration(E2nodeComponentConfiguration_t *e2nodeComponentConfiguration)
4711 /* Free E2 Node Component Request Part */
4712 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentRequestPart.buf, e2nodeComponentConfiguration->e2nodeComponentRequestPart.size);
4714 /* Free E2 Node Component Response Part */
4715 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentResponsePart.buf, e2nodeComponentConfiguration->e2nodeComponentResponsePart.size);
4719 /*******************************************************************
4721 * @brief free e2 node component component identifier
4725 * Function : freeE2NodeComponentIdentifier
4728 * - free e2 node component component identifier
4730 * @params[in] E2nodeComponentID_t *componentID
4731 * @return ROK - success
4734 * ****************************************************************/
4736 void freeE2NodeComponentIdentifier(E2nodeComponentID_t *componentID)
4738 if(componentID->choice.e2nodeComponentInterfaceTypeF1)
4740 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
4741 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
4746 /*******************************************************************
4748 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
4752 * Function : FreeE2NodeConfigUpdate
4755 * - freeing the memory allocated for E2nodeConfigurationUpdate
4757 * @params[in] E2AP_PDU_t *e2apMsg
4758 * @return ROK - success
4761 * ****************************************************************/
4763 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
4765 uint8_t arrIdx =0, e2NodeUpdateListIdx=0, e2NodeRemovalListIdx=0, e2NodeAddListIdx=0;
4766 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate =NULL;
4767 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList =NULL;
4768 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItem =NULL;
4769 E2nodeComponentConfigRemoval_List_t *e2NodeRemovalList =NULL;
4770 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItem =NULL;
4771 E2nodeComponentConfigAddition_List_t *e2NodeAddList =NULL;
4772 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem =NULL;
4774 if(e2apMsg != NULLP)
4776 if(e2apMsg->choice.initiatingMessage != NULLP)
4778 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4779 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
4781 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
4783 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx])
4786 switch(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id)
4788 case ProtocolIE_IDE2_id_TransactionID:
4791 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
4793 e2NodeAddList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
4794 if(e2NodeAddList->list.array)
4796 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
4798 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
4800 freeE2NodeComponentConfiguration(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration);
4801 freeE2NodeComponentIdentifier(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID);
4802 DU_FREE(e2NodeAddItem, sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
4804 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
4808 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
4810 e2NodeUpdateList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List;
4811 if(e2NodeUpdateList->list.array)
4813 for(e2NodeUpdateListIdx = 0; e2NodeUpdateListIdx< e2NodeUpdateList->list.count; e2NodeUpdateListIdx++)
4815 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[e2NodeUpdateListIdx];
4817 freeE2NodeComponentConfiguration(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentConfiguration);
4818 freeE2NodeComponentIdentifier(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentID);
4819 DU_FREE(e2NodeUpdateItem, sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
4821 DU_FREE(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
4825 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
4827 e2NodeRemovalList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List;
4828 if(e2NodeRemovalList->list.array)
4830 for(e2NodeRemovalListIdx = 0; e2NodeRemovalListIdx< e2NodeRemovalList->list.count; e2NodeRemovalListIdx++)
4832 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemovalList->list.array[e2NodeRemovalListIdx];
4834 freeE2NodeComponentIdentifier(&e2NodeRemovalItem->value.choice.E2nodeComponentConfigRemoval_Item.e2nodeComponentID);
4835 DU_FREE(e2NodeRemovalItem, sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
4837 DU_FREE(e2NodeRemovalList->list.array, e2NodeRemovalList->list.size);
4845 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4848 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4850 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4852 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4856 /*******************************************************************
4858 * @brief Buld and send the E2 node config update msg
4862 * Function : BuildAndSendE2NodeConfigUpdate
4865 * - Buld and send the E2 node config update msg
4868 * @return ROK - success
4871 * ****************************************************************/
4873 uint8_t BuildAndSendE2NodeConfigUpdate(E2NodeConfigList *e2NodeList)
4875 uint8_t ret = RFAILED;
4876 uint8_t arrIdx = 0,elementCnt = 0, transId=0;
4877 E2AP_PDU_t *e2apMsg = NULLP;
4878 asn_enc_rval_t encRetVal; /* Encoder return value */
4879 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
4881 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
4884 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4885 if(e2apMsg == NULLP)
4887 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4891 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4892 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4893 if(e2apMsg->choice.initiatingMessage == NULLP)
4895 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4898 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4899 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
4900 e2apMsg->choice.initiatingMessage->value.present = \
4901 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
4902 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4905 if(e2NodeList->addE2NodeCount)
4907 if(e2NodeList->updateE2NodeCount)
4909 if(e2NodeList->removeE2NodeCount)
4912 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
4913 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
4914 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4915 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
4917 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4921 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
4923 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4924 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
4927 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4932 if(arrIdx<elementCnt)
4936 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4937 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4938 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
4939 transId = assignTransactionId();
4940 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4942 if(e2NodeList->addE2NodeCount)
4945 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
4946 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4947 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigAddition_List;
4948 if(BuildE2NodeConfigAddList(&(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List),\
4949 ProcedureCodeE2_id_E2nodeConfigurationUpdate, e2NodeList->addE2NodeCount, e2NodeList->addE2Node)!=ROK)
4951 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
4956 if(e2NodeList->updateE2NodeCount)
4959 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate;
4960 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4961 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigUpdate_List;
4962 if(BuildE2NodeConfigUpdateList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List,\
4963 e2NodeList->updateE2NodeCount, e2NodeList->updateE2Node) != ROK)
4966 DU_LOG("\nERROR --> E2AP : Failed to update the E2 node configuration");
4971 if(e2NodeList->removeE2NodeCount)
4974 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval;
4975 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4976 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigRemoval_List;
4977 if(BuildE2NodeConfigRemoveList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List,\
4978 e2NodeList->removeE2NodeCount, e2NodeList->removeE2Node) != ROK)
4981 DU_LOG("\nERROR --> E2AP : Failed to remove the E2 node configuration");
4986 /* Prints the Msg formed */
4987 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4989 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4991 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
4992 if(encRetVal.encoded == ENCODE_FAIL)
4994 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
4995 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5000 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
5001 #ifdef DEBUG_ASN_PRINT
5002 for(int i=0; i< encBufSize; i++)
5004 printf("%x",encBuf[i]);
5008 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
5010 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
5014 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5015 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5016 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.e2NodeConfigUpdate.configList, e2NodeList, sizeof(E2NodeConfigList));
5021 FreeE2NodeConfigUpdate(e2apMsg);
5025 /*******************************************************************
5027 * @brief Deallocate the memory allocated for E2ResetRequest msg
5031 * Function : FreeE2ResetRequest
5034 * - freeing the memory allocated for E2ResetRequest
5036 * @params[in] E2AP_PDU_t *e2apMsg
5037 * @return ROK - success
5040 * ****************************************************************/
5041 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
5044 ResetRequestE2_t *resetReq = NULLP;
5046 if(e2apMsg != NULLP)
5048 if(e2apMsg->choice.initiatingMessage != NULLP)
5050 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5051 if(resetReq->protocolIEs.list.array)
5053 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
5055 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5057 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5059 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5061 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5065 /*******************************************************************
5067 * @brief Build and send the E2 reset request msg
5071 * Function : BuildAndSendE2ResetRequest
5074 * - Buld and send the E2 reset request msg to RIC
5078 * @return ROK - success
5081 * ****************************************************************/
5082 uint8_t BuildAndSendE2ResetRequest(E2FailureCause resetCause)
5084 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
5085 uint8_t ret = RFAILED;
5086 E2AP_PDU_t *e2apMsg = NULLP;
5087 ResetRequestE2_t *resetReq = NULLP;
5088 asn_enc_rval_t encRetVal; /* Encoder return value */
5090 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
5094 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5095 if(e2apMsg == NULLP)
5097 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
5101 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5102 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5103 if(e2apMsg->choice.initiatingMessage == NULLP)
5105 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
5109 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
5110 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5111 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
5112 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
5115 resetReq->protocolIEs.list.count = elementCnt;
5116 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
5118 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
5119 if(!resetReq->protocolIEs.list.array)
5121 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5122 Reset Request IE array");
5126 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5128 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
5129 if(!resetReq->protocolIEs.list.array[ieIdx])
5131 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
5132 Reset Request IE array element");
5137 /* In case of failure */
5138 if(ieIdx < elementCnt)
5142 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5143 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
5144 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
5145 transId = assignTransactionId();
5146 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
5149 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
5150 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
5151 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
5152 fillE2Cause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, resetCause);
5154 /* Prints the Msg formed */
5155 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5157 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5159 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
5161 if(encRetVal.encoded == ENCODE_FAIL)
5163 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
5164 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5169 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
5170 #ifdef DEBUG_ASN_PRINT
5171 for(int i=0; i< encBufSize; i++)
5173 printf("%x",encBuf[i]);
5177 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5179 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5183 /* In case the message is sent successfully, store the transaction info to
5184 * be used when response is received */
5185 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5186 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5192 /* Free all memory */
5193 FreeE2ResetRequest(e2apMsg);
5197 /*******************************************************************
5199 * @brief Deallocate the memory allocated for Reset Response msg
5203 * Function : freeAperDecodingOfE2ResetRsp
5206 * - freeing the memory allocated for Reset response
5208 * @params[in] ResetResponseE2_t *resetResponse
5211 * ****************************************************************/
5212 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
5218 if(resetResponse->protocolIEs.list.array)
5220 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5222 if(resetResponse->protocolIEs.list.array[ieIdx])
5224 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5226 case ProtocolIE_IDE2_id_TransactionID:
5229 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5232 free(resetResponse->protocolIEs.list.array[ieIdx]);
5235 free(resetResponse->protocolIEs.list.array);
5240 /******************************************************************
5242 * @brief Processes E2 Reset Response sent by RIC
5246 * Function : procResetResponse
5248 * Functionality: Processes E2 Reset Response sent by RIC
5250 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5253 * ****************************************************************/
5254 void procResetResponse(E2AP_PDU_t *e2apMsg)
5256 bool invalidTransId=false;
5257 uint8_t ieIdx =0, transId =0;
5258 uint16_t ranFuncIdx=0;
5259 ResetResponseE2_t *resetResponse =NULLP;
5261 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
5262 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
5264 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
5266 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
5268 case ProtocolIE_IDE2_id_TransactionID:
5270 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5271 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \
5272 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
5274 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5278 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5279 invalidTransId = true;
5283 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5285 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
5287 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
5289 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
5290 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
5297 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
5298 resetResponse->protocolIEs.list.array[ieIdx]->id);
5303 if(invalidTransId == true)
5309 freeAperDecodingOfE2ResetRsp(resetResponse);
5312 /******************************************************************
5314 * @brief Deallocation of memory allocated by aper decoder for e2 setup Failure
5318 * Function : freeAperDecodingOfE2SetupFailure
5320 * Functionality: Deallocation of memory allocated by aper decoder for e2
5323 * @params[in] E2setupFailure_t *e2SetupFailure;
5326 * ****************************************************************/
5327 void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure)
5333 if(e2SetupFailure->protocolIEs.list.array)
5335 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5337 if(e2SetupFailure->protocolIEs.list.array[arrIdx])
5339 free(e2SetupFailure->protocolIEs.list.array[arrIdx]);
5342 free(e2SetupFailure->protocolIEs.list.array);
5346 /******************************************************************
5348 * @brief Processes E2 Setup Failure sent by RIC
5352 * Function : procE2SetupFailure
5354 * Functionality: Processes E2 Setup failure sent by RIC
5356 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5357 * @return ROK - success
5360 * ****************************************************************/
5361 void procE2SetupFailure(E2AP_PDU_t *e2apMsg)
5363 uint8_t arrIdx =0, transId =0, timerValue=0;
5364 E2setupFailure_t *e2SetupFailure;
5366 DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
5367 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
5369 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
5371 switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id)
5373 case ProtocolIE_IDE2_id_TransactionID:
5375 transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5376 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
5377 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5379 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5383 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5388 case ProtocolIE_IDE2_id_TimeToWaitE2:
5390 timerValue = convertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
5391 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE)
5393 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue);
5397 DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
5405 freeAperDecodingOfE2SetupFailure(e2SetupFailure);
5407 /******************************************************************
5409 * @brief Deallocation of memory allocated by aper decoder for RIC service Query
5413 * Function : freeAperDecodingOfRicServiceQuery
5415 * Functionality: Deallocation of memory allocated by aper decoder for RIC
5418 * @params[in] RICserviceQuery_t *ricServiceQuery;
5421 * ****************************************************************/
5423 void freeAperDecodingOfRicServiceQuery(RICserviceQuery_t *ricServiceQuery)
5425 uint8_t arrIdx,ranFuncIdx;
5426 RANfunctionsID_List_t *ranFuncAddedList;
5430 if(ricServiceQuery->protocolIEs.list.array)
5432 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5434 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
5436 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5438 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5440 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5441 if(ranFuncAddedList->list.array)
5443 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5445 free(ranFuncAddedList->list.array[ranFuncIdx]);
5447 free(ranFuncAddedList->list.array);;
5454 free(ricServiceQuery->protocolIEs.list.array[arrIdx]);
5457 free(ricServiceQuery->protocolIEs.list.array);
5461 /*******************************************************************
5463 * @brief Build RanFunction Delete List
5467 * Function : BuildRanFunctionDeleteList
5469 * Functionality: Build RanFunction Delete List
5472 * RANfunctionsID List
5473 * Count of the RAN function
5474 * Received RAN function list
5476 * @return ROK - success
5479 ******************************************************************/
5481 uint8_t BuildRanFunctionDeleteList(RANfunctionsID_List_t *deleteList, uint8_t count, RanFuncInfo *recvdRanFunc)
5483 uint8_t ranFuncIdx=0;
5484 RANfunctionID_ItemIEs_t *delRanFuncItem;
5488 deleteList->list.count = count;
5489 deleteList->list.size = deleteList->list.count * sizeof(RANfunctionID_ItemIEs_t*);
5490 DU_ALLOC(deleteList->list.array, deleteList->list.size);
5491 if(deleteList->list.array == NULLP)
5493 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5496 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
5498 DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t));
5499 if(deleteList->list.array[ranFuncIdx] == NULLP)
5501 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
5504 delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx];
5505 delRanFuncItem->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
5506 delRanFuncItem->criticality = CriticalityE2_ignore;
5507 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionID = recvdRanFunc[ranFuncIdx].id;
5508 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionRevision = recvdRanFunc[ranFuncIdx].revisionCounter;
5514 /*******************************************************************
5516 * @brief De Allocate Ric Service Update message
5520 * Function : FreeRicServiceUpdate
5522 * Functionality: De-Allocating Ric Service Update message
5524 * @params[in] E2AP_PDU_t *e2apMsg
5528 * ****************************************************************/
5530 void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg)
5533 uint8_t ranFuncAddListIdx=0, ranFuncDelIdx=0;
5534 RICserviceUpdate_t *ricServiceUpdate;
5535 RANfunctions_List_t *ranFunctionsList;
5536 RANfunction_ItemIEs_t *ranFuncItemIe;
5537 RANfunction_Item_t *ranFunItem;
5538 RANfunctionsID_List_t *deleteList;
5540 /* De-allocating Memory */
5541 if(e2apMsg != NULLP)
5543 if(e2apMsg->choice.initiatingMessage != NULLP)
5545 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5546 if(ricServiceUpdate->protocolIEs.list.array != NULLP)
5548 for(arrIdx = 0; arrIdx < ricServiceUpdate->protocolIEs.list.count; arrIdx++)
5550 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] != NULLP)
5552 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
5554 case ProtocolIE_IDE2_id_TransactionID:
5557 case ProtocolIE_IDE2_id_RANfunctionsAdded:
5558 case ProtocolIE_IDE2_id_RANfunctionsModified:
5560 ranFunctionsList = &(ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
5561 if(ranFunctionsList->list.array)
5563 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
5565 if(ranFunctionsList->list.array[ranFuncAddListIdx])
5567 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
5568 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
5569 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
5570 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
5571 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
5574 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
5578 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
5580 deleteList= &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5581 if(deleteList->list.array)
5583 for(ranFuncDelIdx = 0; ranFuncDelIdx< deleteList->list.count; ranFuncDelIdx++)
5585 DU_FREE(deleteList->list.array[ranFuncDelIdx], sizeof(RANfunctionID_ItemIEs_t));
5587 DU_FREE(deleteList->list.array, deleteList->list.size);
5593 DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
5594 (ricServiceUpdate->protocolIEs.list.array[arrIdx]->id));
5597 DU_FREE(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5600 DU_FREE(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5602 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5604 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5608 /*******************************************************************
5610 * @brief Builds and Send the RicServiceUpdateuest
5614 * Function : BuildAndSendRicServiceUpdate
5616 * Functionality:Fills the RicServiceUpdateuest
5618 * @return ROK - success
5621 ******************************************************************/
5623 uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate)
5625 uint8_t arrIdx = 0, elementCnt=0;
5626 uint8_t transId = 0, ret = RFAILED;
5627 bool memAllocFailed =false;
5628 E2AP_PDU_t *e2apMsg = NULLP;
5629 RICserviceUpdate_t *ricServiceUpdate = NULLP;
5630 asn_enc_rval_t encRetVal; /* Encoder return value */
5632 DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n");
5635 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5636 if(e2apMsg == NULLP)
5638 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5641 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5642 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5643 if(e2apMsg->choice.initiatingMessage == NULLP)
5645 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5648 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5649 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
5650 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceUpdate;
5651 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5653 /* For TransId IE, set elementCnt to 1.
5654 If there is any item in the RAN function add list, RAN function modification list, or RAN function delete list, increment the elementCnt.*/
5657 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5659 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5661 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5664 ricServiceUpdate->protocolIEs.list.count = elementCnt;
5665 ricServiceUpdate->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdate_IEs_t*);
5667 /* Initialize the E2Setup members */
5668 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5669 if(ricServiceUpdate->protocolIEs.list.array == NULLP)
5671 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
5675 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
5677 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5678 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP)
5680 memAllocFailed = true;
5681 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
5685 if(memAllocFailed == true)
5691 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5692 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5693 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
5694 if(serviceUpdate.dir == E2_NODE_INITIATED)
5695 transId = assignTransactionId();
5697 transId = serviceUpdate.transId;
5698 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5700 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5703 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
5704 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5705 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5706 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,\
5707 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded, serviceUpdate.recvRanFuncList.ranFunToBeAdded) !=ROK)
5713 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5716 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsModified;
5717 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5718 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5719 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,
5720 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeModified, serviceUpdate.recvRanFuncList.ranFunToBeModified) !=ROK)
5726 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5729 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsDeleted;
5730 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5731 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctionsID_List;
5732 if(BuildRanFunctionDeleteList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List,\
5733 serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted, serviceUpdate.recvRanFuncList.ranFunToBeDeleted) != ROK)
5738 /* Prints the Msg formed */
5739 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5741 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5743 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5744 if(encRetVal.encoded == ENCODE_FAIL)
5746 DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
5747 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5752 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
5753 #ifdef DEBUG_ASN_PRINT
5754 for(int i=0; i< encBufSize; i++)
5756 printf("%x",encBuf[i]);
5760 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5762 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5771 if(serviceUpdate.dir == E2_NODE_INITIATED)
5773 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5774 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5778 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId = transId;
5779 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5781 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.dir = serviceUpdate.dir;
5782 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.transId =transId;
5783 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.recvRanFuncList, &serviceUpdate.recvRanFuncList, sizeof(E2TmpRanFunList));
5785 FreeRicServiceUpdate(e2apMsg);
5788 /******************************************************************
5790 * @brief Processes RIC service Query sent by RIC
5794 * Function : procRicServiceQuery
5796 * Functionality: Processes RIC service Query sent by RIC
5798 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5799 * @return ROK - success
5802 * ****************************************************************/
5804 void procRicServiceQuery(E2AP_PDU_t *e2apMsg)
5807 uint16_t arrIdx =0, ranFuncIdx=0,tmpIdx=0;
5808 uint16_t id,revisionCcounter;
5809 bool tmpArray[MAX_RAN_FUNCTION] = {false};
5810 RICserviceQuery_t *ricServiceQuery=NULL;
5811 RicServiceUpdate ricUpdate;
5812 RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
5813 RANfunctionsID_List_t *ranFuncAddedList;
5815 DU_LOG("\nINFO --> E2AP : RIC Service Query received");
5816 memset(&ricUpdate, 0, sizeof(RicServiceUpdate));
5817 ricUpdate.dir = RIC_INITIATED;
5818 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
5820 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5822 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5824 /* TODO completing in next patch/gerrit */
5825 case ProtocolIE_IDE2_id_TransactionID:
5827 ricUpdate.transId = ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5831 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5833 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5834 if(ranFuncAddedList->list.array)
5836 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5838 if(ranFuncAddedList->list.array[ranFuncIdx])
5840 /* Using the RAN function Id, identify the RAN function to be modified or deleted. */
5842 ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
5843 id = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID;
5844 revisionCcounter = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision;
5846 if((id != duCb.e2apDb.ranFunction[id-1].id))
5848 action = CONFIG_DEL;
5850 else if((id == duCb.e2apDb.ranFunction[id-1].id)&&(revisionCcounter!=duCb.e2apDb.ranFunction[id-1].revisionCounter))
5852 action = CONFIG_MOD;
5855 if(action == CONFIG_DEL)
5857 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].id = id;
5858 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].revisionCounter = revisionCcounter;
5859 ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted++;
5861 else if(action == CONFIG_MOD)
5863 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].id = id;
5864 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].revisionCounter = revisionCcounter;
5865 ricUpdate.recvRanFuncList.numOfRanFunToBeModified++;
5868 /* If any ID is set to true, it means that the ID has been used in either modification or deletion list.
5869 * Else we will add the IDs into the added list */
5870 tmpArray[id-1] = true;
5879 /* Traversing the whole RAN function list in ducb to check if any new Ran function ids have been added. */
5880 for(arrIdx =0; arrIdx<MAX_RAN_FUNCTION; arrIdx++)
5882 tmpIdx= ricUpdate.recvRanFuncList.numOfRanFunToBeAdded;
5883 if((duCb.e2apDb.ranFunction[arrIdx].id >0)&&(!tmpArray[arrIdx]))
5885 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[arrIdx].id;
5886 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[arrIdx].revisionCounter;
5887 ricUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
5891 if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK)
5893 DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message");
5896 freeAperDecodingOfRicServiceQuery(ricServiceQuery);
5899 /******************************************************************
5901 * @brief Deallocation of memory allocated by aper decoder for
5902 * RIC service update ack
5906 * Function : freeAperDecodingOfRicServiceUpdateAck
5908 * Functionality: Deallocation of memory allocated by aper decoder
5909 * for RIC service update ack
5911 * @params[in] RICserviceUpdateAck_t *ricServiceAck;
5914 * ****************************************************************/
5916 void freeAperDecodingOfRicServiceUpdateAck(RICserviceUpdateAcknowledge_t *ricServiceAck)
5918 uint8_t arrIdx=0,ranFuncIdx=0;
5919 RANfunctionsID_List_t *ranFuncAddedList=NULL;
5923 if(ricServiceAck->protocolIEs.list.array)
5925 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5927 if(ricServiceAck->protocolIEs.list.array[arrIdx])
5929 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5931 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5933 ranFuncAddedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5934 if(ranFuncAddedList->list.array)
5936 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5938 free(ranFuncAddedList->list.array[ranFuncIdx]);
5940 free(ranFuncAddedList->list.array);
5947 free(ricServiceAck->protocolIEs.list.array[arrIdx]);
5950 free(ricServiceAck->protocolIEs.list.array);
5955 /******************************************************************
5957 * @brief Processes RIC service update ack sent by RIC
5961 * Function : procRicServiceUpdateAck
5963 * Functionality: Processes RIC service update ack sent by RIC
5965 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5966 * @return ROK - success
5969 * ****************************************************************/
5971 void procRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
5973 uint8_t arrIdx =0, transId =0;
5974 uint16_t id =0, tmpIdx=0, ranFuncIdx=0;
5975 RicServiceUpdate serviceUpdate;
5976 RANfunctionsIDcause_List_t *rejectedList=NULL;
5977 RICserviceUpdateAcknowledge_t *ricServiceAck=NULL;
5978 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
5980 DU_LOG("\nINFO --> E2AP : RIC service update ack received");
5981 memset(&serviceUpdate, 0, sizeof(RicServiceUpdate));
5982 ricServiceAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
5984 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5986 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5988 case ProtocolIE_IDE2_id_TransactionID:
5990 transId = ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5991 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
5992 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5994 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5996 else if((duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId == transId) &&\
5997 (duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5999 memset(&duCb.e2apDb.e2TransInfo.ricInitTransaction[transId], 0, sizeof(E2TransInfo));
6003 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
6009 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
6012 case ProtocolIE_IDE2_id_RANfunctionsRejected:
6014 rejectedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
6015 if(rejectedList->list.array)
6017 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
6019 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)rejectedList->list.array[ranFuncIdx];
6020 id = ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID;
6021 tmpIdx= serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded;
6022 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[id-1].id;
6023 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[id-1].revisionCounter;
6024 serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
6033 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
6035 serviceUpdate.dir = E2_NODE_INITIATED;
6036 BuildAndSendRicServiceUpdate(serviceUpdate);
6038 freeAperDecodingOfRicServiceUpdateAck(ricServiceAck);
6041 /******************************************************************
6043 * @brief Deallocation of memory allocated by aper decoder for
6044 * RIC service update failure
6048 * Function : freeAperDecodingOfRicServiceUpdateFailure
6050 * Functionality: Deallocation of memory allocated by aper decoder
6051 * for RIC service update failure
6053 * @params[in] RICserviceUpdateFailure_t *ricServiceFailure;
6056 * ****************************************************************/
6058 void freeAperDecodingOfRicServiceUpdateFailure(RICserviceUpdateFailure_t *ricServiceFailure)
6062 if(ricServiceFailure)
6064 if(ricServiceFailure->protocolIEs.list.array)
6066 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6068 if(ricServiceFailure->protocolIEs.list.array[arrIdx])
6070 free(ricServiceFailure->protocolIEs.list.array[arrIdx]);
6073 free(ricServiceFailure->protocolIEs.list.array);
6078 /******************************************************************
6080 * @brief Processes RIC service update failure sent by RIC
6084 * Function : procRicServiceUpdateFailure
6086 * Functionality: Processes RIC service update failure sent by RIC
6088 * @params[in] E2AP_PDU_t ASN decoded E2AP message
6089 * @return ROK - success
6092 * ****************************************************************/
6094 void procRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
6096 uint8_t arrIdx =0, timerValue=0;
6097 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
6099 DU_LOG("\nINFO --> E2AP : RIC service update failure received");
6100 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
6102 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
6104 switch(ricServiceFailure->protocolIEs.list.array[arrIdx]->id)
6106 case ProtocolIE_IDE2_id_TransactionID:
6110 case ProtocolIE_IDE2_id_TimeToWaitE2:
6112 timerValue = convertE2WaitTimerEnumToValue(ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
6113 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR)) == FALSE)
6115 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR, timerValue);
6119 DU_LOG("\nERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running");
6124 case ProtocolIE_IDE2_id_CauseE2:
6131 freeAperDecodingOfRicServiceUpdateFailure(ricServiceFailure);
6134 /******************************************************************
6136 * @brief DU Send E2 Node Configuration Update
6140 * Function : duSendE2NodeConfigurationUpdate
6142 * Functionality: DU Send E2 Node Configuration Update
6144 * @return ROK - success
6147 * ****************************************************************/
6149 uint8_t duSendE2NodeConfigurationUpdate()
6151 E2NodeConfigList e2NodeList;
6152 CmLList *node =NULL;
6153 E2NodeComponent *e2NodeComponentInfo=NULL;
6155 memset(&e2NodeList, 0, sizeof(E2NodeConfigList));
6156 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
6159 e2NodeComponentInfo = (E2NodeComponent*)node->node;
6161 if(e2NodeComponentInfo->addConfiguration)
6163 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6164 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6165 e2NodeList.addE2NodeCount++;
6168 if(e2NodeComponentInfo->updateConfiguration)
6170 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6171 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].componentId= e2NodeComponentInfo->componentId;
6172 e2NodeList.updateE2NodeCount++;
6175 if(e2NodeComponentInfo->deleteConfiguration == true)
6177 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
6178 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].componentId = e2NodeComponentInfo->componentId;
6179 e2NodeList.removeE2NodeCount++;
6185 if(BuildAndSendE2NodeConfigUpdate(&e2NodeList) !=ROK)
6187 DU_LOG("\nERROR --> E2AP : Failed to build and send e2 node config update message to RIC_stub");
6193 /*******************************************************************
6195 * @brief Free RIC Subscription Modification Required
6199 * Function : FreeRicSubsModRequired
6201 * Functionality: Freqq RIC Subscription Modification required
6203 * @param E2AP Message PDU to be freed
6206 ******************************************************************/
6207 void FreeRicSubsModRequired(E2AP_PDU_t *e2apMsg)
6209 uint8_t ieIdx = 0, arrIdx = 0;
6210 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6211 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6212 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6213 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6217 if(e2apMsg->choice.initiatingMessage)
6219 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6220 if(ricSubsModReqd->protocolIEs.list.array)
6222 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
6224 if(ricSubsModReqd->protocolIEs.list.array[ieIdx])
6226 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6227 switch(ricSubsModReqdIe->id)
6229 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
6231 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6232 if(actionToBeModList->list.array)
6234 for(arrIdx = 0; arrIdx < actionToBeModList->list.count; arrIdx++)
6236 DU_FREE(actionToBeModList->list.array[arrIdx], \
6237 sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6239 DU_FREE(actionToBeModList->list.array, actionToBeModList->list.size);
6244 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
6246 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6247 if(actionToBeRmvList->list.array)
6249 for(arrIdx = 0; arrIdx < actionToBeRmvList->list.count; arrIdx++)
6251 DU_FREE(actionToBeRmvList->list.array[arrIdx], \
6252 sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6254 DU_FREE(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6262 DU_FREE(ricSubsModReqd->protocolIEs.list.array[ieIdx], \
6263 sizeof(RICsubscriptionModificationRequired_IEs_t));
6266 DU_FREE(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6268 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6270 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6274 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6275 * However, E2SM-KPM supports only RIC Report service.
6276 * Hence there is no subsequent action in RIC subscription that may require modification.
6277 * So commenting the action-modification IEs for the time being
6280 /*******************************************************************
6282 * @brief Fill Action required to be modified list
6286 * Function : FillActionReqdToBeModList
6288 * Functionality: Fill Action required to be modified list
6290 * @param RIC Actions Required To Be Modified List to be filled
6291 * Number of actions to be modified
6292 * RIC Subscription DB
6293 * @return ROK - success
6296 ******************************************************************/
6297 uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod,\
6298 RicSubscription *ricSubscription)
6301 CmLList *actionNode = NULLP;
6302 ActionInfo *actionDb = NULLP;
6303 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL;
6305 actionToBeModList->list.count = numActionsMod;
6306 actionToBeModList->list.size = numActionsMod * sizeof(RICaction_RequiredToBeModified_ItemIEs_t *);
6307 DU_ALLOC(actionToBeModList->list.array, actionToBeModList->list.size);
6308 if(!actionToBeModList->list.array)
6310 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6315 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6318 actionDb = (ActionInfo*)(actionNode->node);
6319 if(actionDb->action == CONFIG_MOD)
6321 DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
6322 if(!actionToBeModList->list.array[arrIdx])
6324 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6327 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[arrIdx];
6329 actionToBeMod->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeModified_Item;
6330 actionToBeMod->criticality = CriticalityE2_reject;
6331 actionToBeMod->value.present = \
6332 RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item;
6333 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \
6335 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms;
6344 /*******************************************************************
6346 * @brief Fill Action required to be removed list
6350 * Function : FillActionReqdToBeRmvList
6352 * Functionality: Fill Action required to be removed list
6354 * @param RIC Actions Required To Be Removed List to be filled
6355 * Number of actions to be removed
6356 * RIC Subscription DB
6357 * @return ROK - success
6360 ******************************************************************/
6361 uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \
6362 RicSubscription *ricSubscription)
6365 CmLList *actionNode = NULLP;
6366 ActionInfo *actionDb = NULLP;
6367 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL;
6369 actionToBeRmvList->list.count = numActionsRmv;
6370 actionToBeRmvList->list.size = numActionsRmv * sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t *);
6371 DU_ALLOC(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
6372 if(!actionToBeRmvList->list.array)
6374 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6379 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6382 actionDb = (ActionInfo*)(actionNode->node);
6383 if(actionDb->action == CONFIG_DEL)
6385 DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
6386 if(!actionToBeRmvList->list.array[arrIdx])
6388 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6391 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[arrIdx];
6393 actionToBeRmv->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeRemoved_Item;
6394 actionToBeRmv->criticality = CriticalityE2_reject;
6395 actionToBeRmv->value.present = \
6396 RICaction_RequiredToBeRemoved_ItemIEs__value_PR_RICaction_RequiredToBeRemoved_Item;
6397 actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = actionDb->actionId;
6398 fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, actionDb->failureCause);
6406 /*******************************************************************
6408 * @brief Fill RIC Subscription Modification Required IEs
6412 * Function : FillRicSubsModRequired
6414 * Functionality: Fill RIC Subscription Modification Required IEs
6416 * @param RIC Subscription Modification Required IEs to be filled
6417 * RIC Subscription DB
6418 * @return ROK - success
6421 ******************************************************************/
6422 uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription)
6424 ActionInfo * actionDb=NULLP;
6425 CmLList *actionNode = NULLP;
6426 uint8_t ieIdx = 0, elementCnt=0;
6427 uint8_t numActionsMod = 0, numActionsRmv = 0;
6428 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
6429 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
6431 /* Unused in case of E2SM-KPM */
6433 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
6436 /* Count number of Actions to be modified or deleted */
6437 CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
6440 actionDb = (ActionInfo*)(actionNode->node);
6441 if(actionDb->action == CONFIG_MOD)
6443 else if(actionDb->action == CONFIG_DEL)
6445 actionNode = actionNode->next;
6448 /* Count number of IEs to be added to messages */
6455 ricSubsModReqd->protocolIEs.list.count = elementCnt;
6456 ricSubsModReqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequired_IEs_t *);
6457 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
6458 if(!ricSubsModReqd->protocolIEs.list.array)
6460 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6464 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
6466 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRequired_IEs_t));
6467 if(!ricSubsModReqd->protocolIEs.list.array[ieIdx])
6469 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6474 /* RIC Request ID */
6476 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6477 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICrequestID;
6478 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6479 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RICrequestID;
6480 ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID = ricSubscription->requestId.requestorId;
6481 ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID = ricSubscription->requestId.instanceId;
6483 /* RAN Function ID */
6485 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6486 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RANfunctionID;
6487 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6488 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RANfunctionID;
6489 ricSubsModReqdIe->value.choice.RANfunctionID = ricSubscription->ranFuncId;
6491 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6492 * However, E2SM-KPM supports only RIC Report service.
6493 * Hence there is no subsequent action in RIC subscription that may require modification.
6494 * So commenting the action-modification IEs for the time being
6497 /* RIC Actions Required to be Modified */
6501 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6502 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List;
6503 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6504 ricSubsModReqdIe->value.present = \
6505 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeModified_List;
6506 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
6508 if(FillActionReqdToBeModList(actionToBeModList, numActionsMod, ricSubscription) != ROK)
6510 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__);
6516 /* RIC Actions Required to be removed */
6520 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
6521 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List;
6522 ricSubsModReqdIe->criticality = CriticalityE2_reject;
6523 ricSubsModReqdIe->value.present = \
6524 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeRemoved_List;
6525 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
6527 if(FillActionReqdToBeRmvList(actionToBeRmvList, numActionsRmv, ricSubscription) != ROK)
6529 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__);
6537 /*******************************************************************
6539 * @brief Builds and Send RIC Subscription Modification Required
6544 * Function : BuildAndSendRicSubsModRequired
6546 * Functionality: Builds and Send RIC Subscription Modification
6549 * @param RIC Subscription DB
6550 * @return ROK - success
6553 ******************************************************************/
6554 uint8_t BuildAndSendRicSubsModRequired(RicSubscription *ricSubscription)
6556 uint8_t ret = RFAILED;
6557 E2AP_PDU_t *e2apMsg = NULLP;
6558 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
6559 asn_enc_rval_t encRetVal; /* Encoder return value */
6561 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Required \n");
6564 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6565 if(e2apMsg == NULLP)
6567 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6571 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6572 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6573 if(e2apMsg->choice.initiatingMessage == NULLP)
6575 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
6578 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6579 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
6580 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired;
6582 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6584 if(FillRicSubsModRequired(ricSubsModReqd, ricSubscription) != ROK)
6586 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__);
6591 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6593 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6595 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6596 if(encRetVal.encoded == ENCODE_FAIL)
6598 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modifiction Required structure (at %s)\n",\
6599 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6604 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Required \n");
6605 #ifdef DEBUG_ASN_PRINT
6606 for(int i=0; i< encBufSize; i++)
6608 printf("%x",encBuf[i]);
6612 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
6614 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Modification Required failed");
6621 /* Free RIC Subscription modification required */
6622 FreeRicSubsModRequired(e2apMsg);
6626 /*******************************************************************
6628 * @brief Free APER decoding of RIC Subscription Modification Confirm
6632 * Function : freeAperDecodingOfRicSubsModConfirm
6634 * Functionality: Free APER decoding of RIC Subscription
6635 * Modification Confirm
6637 * @param E2AP Message PDU
6640 ******************************************************************/
6641 void freeAperDecodingOfRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
6643 uint8_t ieIdx = 0, arrIdx=0;
6644 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6645 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6646 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6647 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6648 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6649 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6651 if(e2apMsg && e2apMsg->choice.successfulOutcome)
6653 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6654 if(ricSubsModCfm->protocolIEs.list.array)
6656 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6658 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
6660 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6661 switch(ricSubsModCfmIe->id)
6663 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6665 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6666 if(modCfmList->list.array)
6668 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6670 if(modCfmList->list.array[arrIdx])
6671 free(modCfmList->list.array[arrIdx]);
6673 free(modCfmList->list.array);
6678 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6680 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6681 if(modRefusedList->list.array)
6683 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6685 if(modRefusedList->list.array[arrIdx])
6686 free(modRefusedList->list.array[arrIdx]);
6688 free(modRefusedList->list.array);
6693 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6695 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6696 if(rmvCfmList->list.array)
6698 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6700 if(rmvCfmList->list.array[arrIdx])
6701 free(rmvCfmList->list.array[arrIdx]);
6703 free(rmvCfmList->list.array);
6708 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6710 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6711 if(rmvFailList->list.array)
6713 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6715 if(rmvFailList->list.array[arrIdx])
6716 free(rmvFailList->list.array[arrIdx]);
6718 free(rmvFailList->list.array);
6727 free(ricSubsModCfmIe);
6730 free(ricSubsModCfm->protocolIEs.list.array);
6735 /*******************************************************************
6737 * @brief Process RIC Subscription Modification Confirm Message
6741 * Function : procRicSubscriptionModificationConfirm
6743 * Functionality: Process RIC Subscription Modification Confirm
6744 * Message received from RIC.
6746 * @param E2AP Message PDU
6749 ******************************************************************/
6750 void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg)
6752 uint8_t actionId = 0, ieIdx = 0, arrIdx = 0;
6753 uint16_t ranFuncId = 0;
6754 bool procFailure = false;
6755 RicRequestId ricReqId;
6756 RanFunction *ranFuncDb = NULLP;
6757 CmLList *ricSubsNode = NULLP;
6758 CmLList *actionNode= NULLP;
6759 RicSubscription *ricSubsDb = NULLP;
6760 ActionInfo *actionDb = NULLP;
6762 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6763 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6765 /* Not used in case of E2SM-KPM */
6767 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6768 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
6770 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6771 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
6774 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6775 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
6777 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6778 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
6780 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Confirm", __func__);
6785 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
6789 if(!e2apMsg->choice.successfulOutcome)
6791 DU_LOG("\nERROR --> E2AP : %s: Successful Outcome in E2AP message is NULL", __func__);
6795 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6796 if(!ricSubsModCfm->protocolIEs.list.array)
6798 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
6802 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6804 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
6806 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
6810 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6811 switch(ricSubsModCfmIe->id)
6813 case ProtocolIE_IDE2_id_RICrequestID:
6815 memset(&ricReqId, 0, sizeof(RicRequestId));
6816 ricReqId.requestorId = ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID;
6817 ricReqId.instanceId = ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID;
6821 case ProtocolIE_IDE2_id_RANfunctionID:
6823 ranFuncId = ricSubsModCfmIe->value.choice.RANfunctionID;
6824 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
6827 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
6832 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
6835 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
6836 __func__, ricReqId.requestorId, ricReqId.instanceId);
6844 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6845 * However, E2SM-KPM supports only RIC Report service.
6846 * Hence there is no subsequent action in RIC subscription that may require modification.
6847 * So commenting the action-modification IEs for the time being
6850 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6852 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6853 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6855 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
6856 actionId = modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID;
6858 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6861 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6865 actionDb->action = CONFIG_UNKNOWN;
6866 /* Further handling can be added here in future once the
6867 * use case of this procedure is identified */
6874 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6876 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6877 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6879 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
6880 actionId = modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID;
6881 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6884 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6888 /* Spec doesnt mention if in case of failure, DU should retry for modify action
6889 * Hence, chaging the action from CONFIG_MOD to CONFIG_UNKNOWN
6891 actionDb->action = CONFIG_UNKNOWN;
6899 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6901 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6902 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6904 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
6905 actionId = rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID;
6906 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6909 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6913 cmLListDelFrm(&ricSubsDb->actionSequence, actionNode);
6914 deleteActionSequence(actionNode);
6916 /* Further handling can include :
6917 * Deletion of this action from all DU layers
6925 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6927 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6928 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6930 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
6931 actionId = rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID;
6932 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN);
6935 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6939 actionDb->action = CONFIG_UNKNOWN;
6948 } /* End of switch for Protocol IE Id */
6952 } /* End of for loop for Protocol IE list */
6957 freeAperDecodingOfRicSubsModConfirm(e2apMsg);
6961 /******************************************************************
6962 * @brief Deallocate the memory allocated for E2 Reset Response
6966 * Function : FreeE2ResetResponse
6969 * - freeing the memory allocated for E2ResetResponse
6971 * @params[in] E2AP_PDU_t *e2apMsg
6972 * @return ROK - success
6975 * ****************************************************************/
6976 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
6979 ResetResponseE2_t *resetResponse;
6981 if(e2apMsg != NULLP)
6983 if(e2apMsg->choice.successfulOutcome != NULLP)
6985 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
6986 if(resetResponse->protocolIEs.list.array)
6988 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
6990 if(resetResponse->protocolIEs.list.array[ieIdx])
6992 DU_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
6995 DU_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
6998 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7000 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
7004 /*******************************************************************
7006 * @brief Buld and send the E2 Reset Response msg
7010 * Function : BuildAndSendE2ResetResponse
7013 * - Buld and send the E2 Reset Response Message
7015 * @params[in] Trans Id
7016 * @return ROK - success
7019 * ****************************************************************/
7020 uint8_t BuildAndSendResetResponse(uint8_t transId)
7022 uint8_t ieIdx = 0, elementCnt = 0;
7023 uint8_t ret = RFAILED;
7024 E2AP_PDU_t *e2apMsg = NULLP;
7025 ResetResponseE2_t *resetResponse;
7026 asn_enc_rval_t encRetVal; /* Encoder return value */
7028 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
7031 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7032 if(e2apMsg == NULLP)
7034 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
7037 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7039 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7040 if(e2apMsg->choice.successfulOutcome == NULLP)
7042 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
7046 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
7047 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7048 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
7049 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
7052 resetResponse->protocolIEs.list.count = elementCnt;
7053 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
7054 DU_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
7055 if(!resetResponse->protocolIEs.list.array)
7057 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
7061 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
7063 DU_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
7064 if(!resetResponse->protocolIEs.list.array[ieIdx])
7066 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
7070 if(ieIdx < elementCnt)
7074 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
7075 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
7076 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
7077 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
7079 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7081 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7083 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7084 if(encRetVal.encoded == ENCODE_FAIL)
7086 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
7087 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7092 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
7093 for(int i=0; i< encBufSize; i++)
7095 DU_LOG("%x",encBuf[i]);
7100 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7102 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
7110 FreeE2ResetResponse(e2apMsg);
7114 /******************************************************************
7116 * @brief Deallocation of memory allocated by aper decoder for reset req
7120 * Function : freeAperDecodingOfE2ResetReq
7122 * Functionality: Deallocation of memory allocated by aper decoder for
7125 * @params[in] Pointer to resetReq
7128 * ****************************************************************/
7129 void freeAperDecodingOfE2ResetReq(ResetRequestE2_t *resetReq)
7135 if(resetReq->protocolIEs.list.array)
7137 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7139 if(resetReq->protocolIEs.list.array[arrIdx])
7141 free(resetReq->protocolIEs.list.array[arrIdx]);
7144 free(resetReq->protocolIEs.list.array);
7149 /*******************************************************************
7151 * @brief Process reset req received from RIC
7155 * Function : procE2ResetRequest
7157 * Functionality: Process reset req received from RIC
7159 * @param E2AP_PDU_t *e2apMsg
7162 ******************************************************************/
7164 void procE2ResetRequest(E2AP_PDU_t *e2apMsg)
7166 uint16_t ranFuncIdx=0;
7167 uint8_t arrIdx =0, transId =0;
7168 ResetRequestE2_t *resetReq;
7170 DU_LOG("\nINFO --> E2AP : E2 Reset request received");
7171 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
7173 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
7175 switch(resetReq->protocolIEs.list.array[arrIdx]->id)
7177 case ProtocolIE_IDE2_id_TransactionID:
7179 transId = resetReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
7183 case ProtocolIE_IDE2_id_CauseE2:
7185 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
7187 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
7189 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
7190 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
7197 if(BuildAndSendResetResponse(transId) != ROK)
7199 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
7201 freeAperDecodingOfE2ResetReq(resetReq);
7204 /*******************************************************************
7206 * @brief Free APER decoding of RIC Subscription Modification Refuse
7210 * Function : freeAperDecodingOfRicSubsModRefuse
7212 * Functionality: Free APER decoding of RIC Subscription
7213 * Modification Refuse
7215 * @param E2AP Message PDU
7218 ******************************************************************/
7219 void freeAperDecodingOfRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
7222 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7224 if(e2apMsg && e2apMsg->choice.unsuccessfulOutcome)
7226 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7227 if(ricSubsModRefuse->protocolIEs.list.array)
7229 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7231 if(ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7232 free(ricSubsModRefuse->protocolIEs.list.array[ieIdx]);
7234 free(ricSubsModRefuse->protocolIEs.list.array);
7239 /*******************************************************************
7241 * @brief Process RIC Subscription Modification Refuse Message
7245 * Function : procRicSubscriptionModificationRefuse
7247 * Functionality: Process RIC Subscription Modification Refuse
7248 * Message received from RIC.
7250 * @param E2AP Message PDU
7253 ******************************************************************/
7254 void procRicSubscriptionModificationRefuse(E2AP_PDU_t *e2apMsg)
7257 uint16_t ranFuncId = 0;
7258 RicRequestId ricReqId;
7259 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
7260 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
7261 CauseE2_t *cause = NULLP;
7263 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Refuse", __func__);
7268 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
7272 if(!e2apMsg->choice.unsuccessfulOutcome)
7274 DU_LOG("\nERROR --> E2AP : %s: Unsuccessful Outcome in E2AP message is NULL", __func__);
7278 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
7279 if(!ricSubsModRefuse->protocolIEs.list.array)
7281 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
7285 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
7287 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
7289 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
7293 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
7294 switch(ricSubsModRefuseIe->id)
7296 case ProtocolIE_IDE2_id_RICrequestID:
7298 memset(&ricReqId, 0, sizeof(RicRequestId));
7299 ricReqId.requestorId = ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID;
7300 ricReqId.instanceId = ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID;
7304 case ProtocolIE_IDE2_id_RANfunctionID:
7306 ranFuncId = ricSubsModRefuseIe->value.choice.RANfunctionID;
7310 case ProtocolIE_IDE2_id_CauseE2:
7312 DU_LOG("\nDEBUG --> E2AP : %s: RIC subscriptiom modification refused for RIC_Requestor_ID [%d] \
7313 RIC_Instance_ID [%d] RAN_Function_ID [%d] ", __func__, ricReqId.requestorId, \
7314 ricReqId.instanceId, ranFuncId);
7316 cause = &ricSubsModRefuseIe->value.choice.CauseE2;
7317 printE2ErrorCause(cause);
7322 } /* End of switch for Protocol IE Id */
7323 } /* End of for loop for Protocol IE list */
7328 freeAperDecodingOfRicSubsModRefuse(e2apMsg);
7332 /*******************************************************************
7334 * @brief Free RIC Subscription Delete Required Message
7338 * Function : FreeRicSubscriptionDeleteRequired
7340 * Functionality: Free RIC Subscription Delete Required
7342 * @param E2AP Message PDU
7345 ******************************************************************/
7346 void FreeRicSubscriptionDeleteRequired(E2AP_PDU_t *e2apMsg, CmLListCp *ricSubsToBeDelList)
7348 uint8_t ieIdx = 0, arrIdx = 0;
7349 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7350 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7351 RICsubscription_List_withCause_t *ricSubsList = NULLP;
7352 CmLList *subsNode = NULLP;
7356 if(e2apMsg->choice.initiatingMessage)
7358 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7359 if(ricSubsDelRqd->protocolIEs.list.array)
7361 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
7363 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx])
7365 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7366 switch(ricSubsDelRqdIe->id)
7368 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
7370 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
7371 if(ricSubsList->list.array)
7373 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
7375 DU_FREE(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7377 DU_FREE(ricSubsList->list.array, ricSubsList->list.size);
7382 DU_FREE(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7385 DU_FREE(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7387 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7389 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7392 if(ricSubsToBeDelList)
7394 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7397 cmLListDelFrm(ricSubsToBeDelList, subsNode);
7398 DU_FREE(subsNode, sizeof(CmLList));
7399 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
7404 /*******************************************************************
7406 * @brief Fill list of RIC subscriptions required to be deleted
7407 * with the cause of deletion
7411 * Function : fillRicSubsListWithCause
7413 * Functionality: Fill list of RIC subscriptions required to be
7414 * deleted with the cause of deletion
7416 * @param E2AP Message PDU
7419 ******************************************************************/
7420 uint8_t fillRicSubsListWithCause(RICsubscription_List_withCause_t *ricSubsList, CmLListCp ricSubsToBeDelList)
7423 CmLList *subsNode = NULLP;
7424 RicSubscription *subsInfo = NULLP;
7425 RICsubscription_withCause_ItemIEs_t *subsItemIe = NULLP;
7426 RICsubscription_withCause_Item_t *subsItem = NULLP;
7428 ricSubsList->list.count = ricSubsToBeDelList.count;
7429 ricSubsList->list.size = ricSubsList->list.count * sizeof(RICsubscription_withCause_ItemIEs_t *);
7430 DU_ALLOC(ricSubsList->list.array, ricSubsList->list.size);
7431 if(!ricSubsList->list.array)
7433 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7437 CM_LLIST_FIRST_NODE(&ricSubsToBeDelList, subsNode);
7438 while(subsNode && (ieIdx < ricSubsList->list.count))
7440 subsInfo = (RicSubscription *)subsNode->node;
7441 DU_ALLOC(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
7442 if(!ricSubsList->list.array[ieIdx])
7444 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7448 subsItemIe = (RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[ieIdx];
7449 subsItemIe->id = ProtocolIE_IDE2_id_RICsubscription_withCause_Item;
7450 subsItemIe->criticality = CriticalityE2_ignore;
7451 subsItemIe->value.present = RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item;
7453 subsItem = & subsItemIe->value.choice.RICsubscription_withCause_Item;
7454 subsItem->ricRequestID.ricRequestorID = subsInfo->requestId.requestorId;
7455 subsItem->ricRequestID.ricInstanceID = subsInfo->requestId.instanceId;
7456 subsItem->ranFunctionID = subsInfo->ranFuncId;
7457 fillE2Cause(&subsItem->cause, subsInfo->failureCause);
7460 subsNode = subsNode->next;
7466 /*******************************************************************
7468 * @brief Builds and Send RIC Subscription delete required
7472 * Function : BuildAndSendRicSubscriptionDeleteRequired
7474 * Functionality: Build and send RIC subscription delete required.
7475 * There can be 2 approaches to trigger following. One of these
7476 * approaches may/may not be implemented in future:
7477 * 1. It can be triggerred immediately when a RIC subscription's
7478 * End Time has expired. In this case, only this subscription's
7479 * info will be sent in this message.
7480 * Since we have not yet added support to execute RIC
7481 * Subscription based on Start Time and End Timer, this message is
7482 * not triggered anywhere from DU APP yet.
7483 * 2. Another approach is to have a periodic timer to check subscription
7484 * status running in background.
7485 * When RIC Subscription End Time expires, this subscription is
7486 * marked to be deleted. Later when this background timer expires,
7487 * a RIC Subscription delete required is sent with all the
7488 * subscription's info which is marked to be deleted.
7489 * The following function is implemented keeping in mind the second
7493 * @return ROK - success
7496 ******************************************************************/
7497 uint8_t BuildAndSendRicSubscriptionDeleteRequired()
7499 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7500 E2AP_PDU_t *e2apMsg = NULLP;
7501 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
7502 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
7503 asn_enc_rval_t encRetVal; /* Encoder return value */
7504 CmLListCp ricSubsToBeDelList;
7508 /* Check if there are any RIC subscriptions to be deleted */
7509 cmLListInit(&ricSubsToBeDelList);
7510 fetchRicSubsToBeDeleted(&ricSubsToBeDelList);
7511 if(ricSubsToBeDelList.count == 0)
7513 DU_LOG("\nDEBUG --> E2AP : %s: No RIC subscriptions are required to be deleted", __func__);
7517 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Required Message\n");
7519 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7520 if(e2apMsg == NULLP)
7522 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7526 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
7527 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7528 if(e2apMsg->choice.initiatingMessage == NULLP)
7530 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7533 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDeleteRequired;
7534 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
7535 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired;
7537 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
7540 ricSubsDelRqd->protocolIEs.list.count = elementCnt;
7541 ricSubsDelRqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequired_IEs_t *);
7543 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
7544 if(ricSubsDelRqd->protocolIEs.list.array == NULLP)
7546 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7550 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7552 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
7553 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx] == NULLP)
7555 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7556 __func__, ieIdx, __LINE__);
7560 if(ieIdx < elementCnt)
7564 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
7565 ricSubsDelRqdIe->id = ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved;
7566 ricSubsDelRqdIe->criticality = CriticalityE2_ignore;
7567 ricSubsDelRqdIe->value.present = RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause;
7568 if(fillRicSubsListWithCause(&ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause, ricSubsToBeDelList)\
7571 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription list with cause", __func__);
7575 /* Prints the Msg formed */
7576 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7577 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7579 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7580 if(encRetVal.encoded == ENCODE_FAIL)
7582 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Required Message (at %s)\n",\
7583 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7588 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Required Message \n");
7589 #ifdef DEBUG_ASN_PRINT
7590 for(int i=0; i< encBufSize; i++)
7592 printf("%x",encBuf[i]);
7597 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7599 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Required Message");
7606 FreeRicSubscriptionDeleteRequired(e2apMsg, &ricSubsToBeDelList);
7610 /*******************************************************************
7612 * @brief Free RIC Subscription Delete Failure Message
7616 * Function : FreeRicSubscriptionDeleteFailure
7618 * Functionality: Free RIC Subscription Delete Failure
7620 * @param E2AP Message PDU
7623 ******************************************************************/
7624 void FreeRicSubscriptionDeleteFailure(E2AP_PDU_t *e2apMsg)
7627 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7631 if(e2apMsg->choice.unsuccessfulOutcome)
7633 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7634 if(ricSubsDelFailure->protocolIEs.list.array)
7636 for(ieIdx = 0; ieIdx < ricSubsDelFailure->protocolIEs.list.count; ieIdx++)
7638 DU_FREE(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7640 DU_FREE(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7642 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7644 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7648 /*******************************************************************
7650 * @brief Builds and Send RIC Subscription Delete Failure
7654 * Function : BuildAndSendRicSubscriptionDeleteFailure
7656 * Functionality: Build and send RIC Subscription Delete Failure.
7662 * @return ROK - success
7665 ******************************************************************/
7666 uint8_t BuildAndSendRicSubscriptionDeleteFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
7668 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7669 E2AP_PDU_t *e2apMsg = NULLP;
7670 RICsubscriptionDeleteFailure_t *ricSubsDelFailure = NULLP;
7671 RICsubscriptionDeleteFailure_IEs_t *ricSubsDelFailureIe = NULLP;
7672 asn_enc_rval_t encRetVal; /* Encoder return value */
7676 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Failure Message\n");
7678 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7679 if(e2apMsg == NULLP)
7681 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7685 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
7686 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
7687 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
7689 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7692 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7693 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
7694 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteFailure;
7697 ricSubsDelFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
7700 ricSubsDelFailure->protocolIEs.list.count = elementCnt;
7701 ricSubsDelFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteFailure_IEs_t *);
7703 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array, ricSubsDelFailure->protocolIEs.list.size);
7704 if(ricSubsDelFailure->protocolIEs.list.array == NULLP)
7706 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7710 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7712 DU_ALLOC(ricSubsDelFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteFailure_IEs_t));
7713 if(ricSubsDelFailure->protocolIEs.list.array[ieIdx] == NULLP)
7715 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7716 __func__, ieIdx, __LINE__);
7720 if(ieIdx < elementCnt)
7724 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7725 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
7726 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7727 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
7728 ricSubsDelFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7729 ricSubsDelFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7732 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7733 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7734 ricSubsDelFailureIe->criticality = CriticalityE2_reject;
7735 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
7736 ricSubsDelFailureIe->value.choice.RANfunctionID = ranFuncId;
7739 ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
7740 ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
7741 ricSubsDelFailureIe->criticality = CriticalityE2_ignore;
7742 ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_CauseE2;
7743 fillE2Cause(&ricSubsDelFailureIe->value.choice.CauseE2, failureCause);
7745 /* Prints the Msg formed */
7746 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7747 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7749 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7750 if(encRetVal.encoded == ENCODE_FAIL)
7752 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Failure Message (at %s)\n",\
7753 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7758 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Failure Message \n");
7759 #ifdef DEBUG_ASN_PRINT
7760 for(int i=0; i< encBufSize; i++)
7762 printf("%x",encBuf[i]);
7767 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7769 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Failure Message");
7777 FreeRicSubscriptionDeleteFailure(e2apMsg);
7782 /*******************************************************************
7784 * @brief Free RIC Subscription Delete Response Message
7788 * Function : FreeRicSubscriptionDeleteResponse
7790 * Functionality: Free RIC Subscription Delete Response
7792 * @param E2AP Message PDU
7795 ******************************************************************/
7796 void FreeRicSubscriptionDeleteResponse(E2AP_PDU_t *e2apMsg)
7799 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7803 if(e2apMsg->choice.successfulOutcome)
7805 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7806 if(ricSubsDelRsp->protocolIEs.list.array)
7808 for(ieIdx = 0; ieIdx < ricSubsDelRsp->protocolIEs.list.count; ieIdx++)
7810 DU_FREE(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7812 DU_FREE(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7814 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7816 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
7820 /*******************************************************************
7822 * @brief Builds and Send RIC Subscription delete Response
7826 * Function : BuildAndSendRicSubscriptionDeleteResponse
7828 * Functionality: Build and send RIC subscription delete Response.
7833 * @return ROK - success
7836 ******************************************************************/
7837 uint8_t BuildAndSendRicSubscriptionDeleteResponse(uint16_t ranFuncId, RicRequestId requestId)
7839 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
7840 E2AP_PDU_t *e2apMsg = NULLP;
7841 RICsubscriptionDeleteResponse_t *ricSubsDelRsp = NULLP;
7842 RICsubscriptionDeleteResponse_IEs_t *ricSubsDelRspIe = NULLP;
7843 asn_enc_rval_t encRetVal; /* Encoder return value */
7847 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Response Message\n");
7849 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
7850 if(e2apMsg == NULLP)
7852 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7856 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
7857 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
7858 if(e2apMsg->choice.successfulOutcome == NULLP)
7860 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
7863 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
7864 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
7865 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse;
7868 ricSubsDelRsp = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
7871 ricSubsDelRsp->protocolIEs.list.count = elementCnt;
7872 ricSubsDelRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteResponse_IEs_t *);
7874 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array, ricSubsDelRsp->protocolIEs.list.size);
7875 if(ricSubsDelRsp->protocolIEs.list.array == NULLP)
7877 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
7881 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
7883 DU_ALLOC(ricSubsDelRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteResponse_IEs_t));
7884 if(ricSubsDelRsp->protocolIEs.list.array[ieIdx] == NULLP)
7886 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
7887 __func__, ieIdx, __LINE__);
7891 if(ieIdx < elementCnt)
7895 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7896 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
7897 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7898 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
7899 ricSubsDelRspIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
7900 ricSubsDelRspIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
7903 ricSubsDelRspIe = ricSubsDelRsp->protocolIEs.list.array[ieIdx];
7904 ricSubsDelRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
7905 ricSubsDelRspIe->criticality = CriticalityE2_reject;
7906 ricSubsDelRspIe->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
7907 ricSubsDelRspIe->value.choice.RANfunctionID = ranFuncId;
7909 /* Prints the Msg formed */
7910 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7911 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7913 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
7914 if(encRetVal.encoded == ENCODE_FAIL)
7916 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Response Message (at %s)\n",\
7917 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7922 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Response Message \n");
7923 #ifdef DEBUG_ASN_PRINT
7924 for(int i=0; i< encBufSize; i++)
7926 printf("%x",encBuf[i]);
7931 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7933 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Response Message");
7941 FreeRicSubscriptionDeleteResponse(e2apMsg);
7945 /*******************************************************************
7947 * @brief Free RIC Subscription Delete Request Message
7951 * Function : freeAperDecodingOfRicSubsDeleteReq
7953 * Functionality: Free RIC Subscription Delete Request
7955 * @param E2AP Message PDU
7958 ******************************************************************/
7959 void freeAperDecodingOfRicSubsDeleteReq(E2AP_PDU_t *e2apMsg)
7962 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
7966 if(e2apMsg->choice.initiatingMessage)
7968 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
7969 if(ricSubsDelReq->protocolIEs.list.array)
7971 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
7973 if(ricSubsDelReq->protocolIEs.list.array[ieIdx])
7975 free(ricSubsDelReq->protocolIEs.list.array[ieIdx]);
7978 free(ricSubsDelReq->protocolIEs.list.array);
7984 /*******************************************************************
7986 * @brief Process RIC Subscription delete request
7990 * Function : procRicSubscriptionDeleteRequest
7992 * Functionality: Process RIC subscription delete request.
7993 * Fetch RAN Function and RIC subscription to be deleted.
7994 * Send statistics delete request to MAC for all action sequence
7995 * within this RIC subscription.
7997 * @params[in] E2AP PDU
8000 ******************************************************************/
8001 void procRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
8004 uint16_t ranFuncId = 0;
8005 bool procFailure = false;
8006 RicRequestId ricReqId;
8007 RanFunction *ranFuncDb = NULLP;
8008 CmLList *ricSubsNode = NULLP;
8009 RicSubscription *ricSubsDb = NULLP;
8010 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
8011 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
8013 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Delete Request", __func__);
8018 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
8022 if(!e2apMsg->choice.initiatingMessage)
8024 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
8028 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
8029 if(!ricSubsDelReq->protocolIEs.list.array)
8031 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
8035 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
8037 if(!ricSubsDelReq->protocolIEs.list.array[ieIdx])
8039 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
8043 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
8044 switch(ricSubsDelReqIe->id)
8046 case ProtocolIE_IDE2_id_RICrequestID:
8048 memset(&ricReqId, 0, sizeof(RicRequestId));
8049 ricReqId.requestorId = ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID;
8050 ricReqId.instanceId = ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID;
8054 case ProtocolIE_IDE2_id_RANfunctionID:
8056 ranFuncId = ricSubsDelReqIe->value.choice.RANfunctionID;
8057 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
8060 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
8065 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
8068 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
8069 __func__, ricReqId.requestorId, ricReqId.instanceId);
8074 if(BuildAndSendStatsDeleteReq(ricSubsDb, true) != ROK)
8076 DU_LOG("\nERROR --> E2AP : Failed to build and send ric subscription delete req to du layers");
8083 } /* End of switch for Protocol IE Id */
8087 } /* End of for loop for Protocol IE list */
8092 freeAperDecodingOfRicSubsDeleteReq(e2apMsg);
8096 /*******************************************************************
8098 * @brief Deallocate the memory allocated for E2 node configuration
8099 * update ack msg by aper decoder
8103 * Function : freeAperDecodingOfE2NodeConfigUpdateAck
8106 * - Deallocate the memory allocated for E2 node configuration
8107 * update ack msg by aper decoder
8109 * @params[in] E2AP_PDU_t *e2apMsg
8110 * @return ROK - success
8113 * ****************************************************************/
8115 void freeAperDecodingOfE2NodeConfigUpdateAck(E2nodeConfigurationUpdateAcknowledge_t *updateAckMsg)
8117 uint8_t arrIdx =0, e2NodeConfigIdx=0;
8118 E2nodeComponentConfigUpdateAck_ItemIEs_t *updateAckItemIe=NULL;
8119 E2nodeComponentConfigUpdateAck_List_t *updateAckList=NULL;
8120 E2nodeComponentConfigRemovalAck_ItemIEs_t *removalAckItemIe=NULL;
8121 E2nodeComponentConfigRemovalAck_List_t *removalAckList=NULL;
8122 E2nodeComponentConfigAdditionAck_ItemIEs_t *additionAckItemIte=NULL;
8123 E2nodeComponentConfigAdditionAck_List_t *additionAckList=NULL;
8125 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULLP;
8126 if(updateAckMsg->protocolIEs.list.array != NULLP)
8128 for(arrIdx = 0; arrIdx < updateAckMsg->protocolIEs.list.count; arrIdx++)
8130 if(updateAckMsg->protocolIEs.list.array[arrIdx])
8132 switch(updateAckMsg->protocolIEs.list.array[arrIdx]->id)
8134 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8136 additionAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8137 if(additionAckList->list.array)
8139 for(e2NodeConfigIdx=0; e2NodeConfigIdx<additionAckList->list.count; e2NodeConfigIdx++)
8141 additionAckItemIte = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) additionAckList->list.array[e2NodeConfigIdx];
8142 if(additionAckItemIte)
8144 switch(additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present)
8146 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8148 f1InterfaceInfo = additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8149 free(f1InterfaceInfo->gNB_DU_ID.buf);
8150 free(f1InterfaceInfo);
8156 free(additionAckItemIte);
8158 free(additionAckList->list.array);
8163 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8165 updateAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8166 if(updateAckList->list.array)
8168 for(e2NodeConfigIdx=0; e2NodeConfigIdx<updateAckList->list.count; e2NodeConfigIdx++)
8170 updateAckItemIe = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) updateAckList->list.array[e2NodeConfigIdx];
8173 switch(updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.present)
8175 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8177 f1InterfaceInfo = updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8178 free(f1InterfaceInfo->gNB_DU_ID.buf);
8179 free(f1InterfaceInfo);
8185 free(updateAckItemIe);
8188 free(updateAckList->list.array);
8192 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8194 removalAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8195 if(removalAckList->list.array)
8197 for(e2NodeConfigIdx=0; e2NodeConfigIdx<removalAckList->list.count; e2NodeConfigIdx++)
8199 removalAckItemIe = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) removalAckList->list.array[e2NodeConfigIdx];
8200 if(removalAckItemIe)
8202 switch(removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.present)
8204 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
8206 f1InterfaceInfo = removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
8207 free(f1InterfaceInfo->gNB_DU_ID.buf);
8208 free(f1InterfaceInfo);
8214 free(removalAckItemIe);
8217 free(removalAckList->list.array);
8222 free(updateAckMsg->protocolIEs.list.array[arrIdx]);
8225 free(updateAckMsg->protocolIEs.list.array);
8229 /******************************************************************
8231 * @brief Processes the E2 node config update ack msg
8235 * Function :procE2NodeConfigUpdateAck
8237 * Functionality: Processes the E2 node config update ack msg
8239 * @params[in] E2AP_PDU_t ASN decoded E2AP message
8240 * @return ROK - success
8243 * ****************************************************************/
8245 void procE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
8248 uint16_t e2CfgIdx =0;
8249 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck =NULLP;
8250 E2nodeComponentConfigUpdateAck_List_t *e2NodeConfigUpdateAckList=NULLP;
8251 E2nodeComponentConfigUpdateAck_ItemIEs_t *e2NodeUpdateAckItem=NULLP;
8252 E2nodeComponentConfigRemovalAck_List_t *e2NodeConfigRemovalAckList=NULLP;
8253 E2nodeComponentConfigRemovalAck_ItemIEs_t *e2NodeRemovalAckItem=NULLP;
8254 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULLP;
8255 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAdditionAckItem=NULLP;
8257 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
8259 if(e2NodeConfigUpdateAck->protocolIEs.list.array)
8261 for(arrIdx =0; arrIdx<e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
8263 switch(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id)
8265 case ProtocolIE_IDE2_id_TransactionID:
8269 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
8271 e2NodeConfigAdditionAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
8272 if(e2NodeConfigAdditionAckList->list.array)
8274 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigAdditionAckList->list.count; e2CfgIdx++)
8276 e2NodeAdditionAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2CfgIdx];
8277 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAdditionAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\
8278 ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck);
8283 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
8285 e2NodeConfigUpdateAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
8286 if(e2NodeConfigUpdateAckList->list.array)
8288 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigUpdateAckList->list.count; e2CfgIdx++)
8290 e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[e2CfgIdx];
8291 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeUpdateAckItem->value.choice.E2nodeComponentConfigUpdateAck_Item,\
8292 ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck);
8297 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
8299 e2NodeConfigRemovalAckList = &e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
8300 if(e2NodeConfigRemovalAckList->list.array)
8302 for(e2CfgIdx = 0; e2CfgIdx< e2NodeConfigRemovalAckList->list.count; e2CfgIdx++)
8304 e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[e2CfgIdx];
8305 handleE2NodeConfigUpdateAckIes((PTR)&e2NodeRemovalAckItem->value.choice.E2nodeComponentConfigRemovalAck_Item,\
8306 ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck);
8315 freeAperDecodingOfE2NodeConfigUpdateAck(e2NodeConfigUpdateAck);
8318 /*******************************************************************
8320 * @brief Deallocate the memory allocated for RemovalRequest msg
8324 * Function : FreeRemovalRequest
8327 * - freeing the memory allocated for RemovalRequest
8329 * @params[in] E2AP_PDU_t *e2apMsg
8330 * @return ROK - success
8333 * ****************************************************************/
8334 void FreeRemovalRequest(E2AP_PDU_t *e2apMsg)
8337 E2RemovalRequest_t *removalReq = NULLP;
8339 if(e2apMsg != NULLP)
8341 if(e2apMsg->choice.initiatingMessage != NULLP)
8343 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8344 if(removalReq->protocolIEs.list.array)
8346 for(ieIdx = 0; ieIdx < removalReq->protocolIEs.list.count; ieIdx++)
8348 DU_FREE(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8350 DU_FREE(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8352 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8354 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8358 /*******************************************************************
8360 * @brief Build and send the removal request msg
8364 * Function : BuildAndSendRemovalRequest
8367 * - Buld and send the removal request msg to E2 node
8369 * @return ROK - success
8372 * ****************************************************************/
8374 uint8_t BuildAndSendRemovalRequest()
8376 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
8377 uint8_t ret = RFAILED;
8378 E2AP_PDU_t *e2apMsg = NULLP;
8379 E2RemovalRequest_t *removalReq = NULLP;
8380 asn_enc_rval_t encRetVal; /* Encoder return value */
8382 DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
8386 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8387 if(e2apMsg == NULLP)
8389 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8393 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
8394 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
8395 if(e2apMsg->choice.initiatingMessage == NULLP)
8397 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8401 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2removal;
8402 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
8403 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2RemovalRequest;
8404 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
8407 removalReq->protocolIEs.list.count = elementCnt;
8408 removalReq->protocolIEs.list.size = elementCnt * sizeof(E2RemovalRequestIEs_t *);
8410 DU_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
8411 if(!removalReq->protocolIEs.list.array)
8413 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8417 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
8419 DU_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
8420 if(!removalReq->protocolIEs.list.array[ieIdx])
8422 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8427 /* In case of failure */
8428 if(ieIdx < elementCnt)
8432 removalReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8433 removalReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8434 removalReq->protocolIEs.list.array[ieIdx]->value.present = E2RemovalRequestIEs__value_PR_TransactionID;
8435 transId = assignTransactionId();
8436 removalReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8438 /* Prints the Msg formed */
8439 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8441 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8443 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
8445 if(encRetVal.encoded == ENCODE_FAIL)
8447 DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
8448 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8453 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
8454 #ifdef DEBUG_ASN_PRINT
8455 for(int i=0; i< encBufSize; i++)
8457 printf("%x",encBuf[i]);
8461 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8463 DU_LOG("\nERROR --> E2AP : Sending removal request failed");
8469 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
8470 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
8474 /* Free all memory */
8475 FreeRemovalRequest(e2apMsg);
8480 /******************************************************************
8482 * @brief Deallocation of memory allocated by aper decoder
8483 * for Removal failure
8487 * Function : freeAperDecodingOfE2RemovalFailure
8489 * Functionality: Deallocation of memory allocated by aper decoder
8490 * for Removal failure
8492 * @params[in] Pointer to removalFailure
8495 * ****************************************************************/
8496 void freeAperDecodingOfE2RemovalFailure(E2RemovalFailure_t *removalFailure)
8502 if(removalFailure->protocolIEs.list.array)
8504 for(arrIdx=0; arrIdx<removalFailure->protocolIEs.list.count; arrIdx++)
8506 if(removalFailure->protocolIEs.list.array[arrIdx])
8508 free(removalFailure->protocolIEs.list.array[arrIdx]);
8511 free(removalFailure->protocolIEs.list.array);
8516 /******************************************************************
8518 * @brief Processes the E2 removal failure msg
8522 * Function : procE2RemovalFailure
8524 * Functionality: Processes the E2 removal failure msg
8527 * E2AP_PDU_t *e2apMsg
8531 * ****************************************************************/
8532 void ProcE2RemovalFailure(E2AP_PDU_t *e2apMsg)
8534 uint8_t ieIdx = 0, transId=0;
8535 CauseE2_t *cause = NULLP;
8536 E2RemovalFailure_t *e2RemovalFailure=NULLP;
8538 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
8540 if(!e2RemovalFailure->protocolIEs.list.array)
8542 DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
8546 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
8548 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
8550 switch(e2RemovalFailure->protocolIEs.list.array[ieIdx]->id)
8552 case ProtocolIE_IDE2_id_TransactionID:
8554 transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8555 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8556 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8558 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8562 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8566 case ProtocolIE_IDE2_id_CauseE2:
8568 cause = &e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
8569 printE2ErrorCause(cause);
8574 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
8580 freeAperDecodingOfE2RemovalFailure(e2RemovalFailure);
8583 /******************************************************************
8585 * @brief Deallocation of memory allocated by aper decoder
8586 * for Removal failure
8590 * Function : freeAperDecodingOfE2RemovalResponse
8592 * Functionality: Deallocation of memory allocated by aper decoder
8593 * for Removal failure
8595 * @params[in] Pointer to removalResponse
8598 * ****************************************************************/
8599 void freeAperDecodingOfE2RemovalResponse(E2RemovalResponse_t *removalResponse)
8605 if(removalResponse->protocolIEs.list.array)
8607 for(arrIdx=0; arrIdx<removalResponse->protocolIEs.list.count; arrIdx++)
8609 if(removalResponse->protocolIEs.list.array[arrIdx])
8611 free(removalResponse->protocolIEs.list.array[arrIdx]);
8614 free(removalResponse->protocolIEs.list.array);
8619 /*******************************************************************
8621 * @brief process the E2 Removal Response
8625 * Function : ProcE2RemovalResponse
8627 * Functionality: Process E2 Removal Response
8630 * E2AP_PDU_t *e2apMsg
8633 ******************************************************************/
8635 void ProcE2RemovalResponse(E2AP_PDU_t *e2apMsg)
8637 uint8_t ieIdx = 0, transId=0;
8638 E2RemovalResponse_t *removalRsp = NULLP;
8640 removalRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
8642 if(!removalRsp->protocolIEs.list.array)
8644 DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
8648 for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
8650 if(removalRsp->protocolIEs.list.array[ieIdx])
8652 switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
8654 case ProtocolIE_IDE2_id_TransactionID:
8656 transId = removalRsp->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
8657 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
8658 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
8660 DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
8661 cmInetClose(&ricParams.sockFd);
8662 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
8663 removeE2NodeInformation();
8667 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
8673 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
8680 freeAperDecodingOfE2RemovalResponse(removalRsp);
8683 /*******************************************************************
8685 * @brief Deallocate the memory allocated for E2 Connection Update Failure
8689 * Function : FreeE2ConnectionUpdateFailure
8692 * - freeing the memory allocated for E2ConnectionUpdateFailure
8694 * @params[in] E2AP_PDU_t *e2apMsg
8695 * @return ROK - success
8698 * ****************************************************************/
8699 void FreeE2ConnectionUpdateFailure(E2AP_PDU_t *e2apMsg)
8702 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8704 if(e2apMsg != NULLP)
8706 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
8708 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8709 if(e2ConnectionUpdateFailure->protocolIEs.list.array)
8711 for(ieIdx=0; ieIdx < e2ConnectionUpdateFailure->protocolIEs.list.count; ieIdx++)
8713 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8715 DU_FREE(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8717 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8719 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
8723 /*******************************************************************
8725 * @brief Buld and send the E2 Connection Update Failure msg
8729 * Function : BuildAndSendE2ConnectionUpdateFailure
8732 * - Buld and send the E2 Connection Update Failure Message
8736 * @return ROK - success
8739 * ****************************************************************/
8741 uint8_t BuildAndSendE2ConnectionUpdateFailure(uint16_t transId, E2FailureCause failureCause)
8743 uint8_t ieIdx = 0, elementCnt = 0;
8744 uint8_t ret = RFAILED;
8745 E2AP_PDU_t *e2apMsg = NULLP;
8746 E2connectionUpdateFailure_t *e2ConnectionUpdateFailure=NULLP;
8747 asn_enc_rval_t encRetVal; /* Encoder return value */
8749 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Failure Message\n");
8752 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
8753 if(e2apMsg == NULLP)
8755 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8758 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
8760 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
8761 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
8763 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8767 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
8768 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
8769 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure;
8770 e2ConnectionUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure;
8773 e2ConnectionUpdateFailure->protocolIEs.list.count = elementCnt;
8774 e2ConnectionUpdateFailure->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateFailure_IEs_t *);
8775 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array, e2ConnectionUpdateFailure->protocolIEs.list.size);
8776 if(!e2ConnectionUpdateFailure->protocolIEs.list.array)
8778 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8782 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
8784 DU_ALLOC(e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateFailure_IEs_t));
8785 if(!e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx])
8787 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8791 if(ieIdx < elementCnt)
8795 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
8796 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
8797 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_TransactionID;
8798 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
8802 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
8803 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
8804 e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateFailure_IEs__value_PR_CauseE2;
8805 fillE2Cause(&e2ConnectionUpdateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, failureCause);
8807 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8809 memset(encBuf, 0, ENC_BUF_MAX_LEN);
8811 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
8812 if(encRetVal.encoded == ENCODE_FAIL)
8814 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update failure structure (at %s)\n",\
8815 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8820 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Failure \n");
8821 for(int i=0; i< encBufSize; i++)
8823 DU_LOG("%x",encBuf[i]);
8828 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
8830 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Failure");
8838 FreeE2ConnectionUpdateFailure(e2apMsg);
8842 /*******************************************************************
8844 * @brief fill E2 connection update item
8848 * Function : fillE2connectionUpdateItem
8850 * Functionality: fill E2 connection update item
8853 * E2connectionUpdate Item to be filled
8857 * @return ROK - success
8859 * ****************************************************************/
8861 uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId, uint32_t ipAddress, AssocUsage usage)
8863 CauseE2_t *cause=NULLP;
8864 TNLusage_t *tnlUsage=NULLP;
8865 E2FailureCause failureCause;
8866 TNLinformation_t *tnlInformation = NULLP;
8867 E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
8868 E2connectionSetupFailed_Item_t *connectionRemoveITem=NULLP;
8872 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8874 connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
8875 tnlInformation = &connectionModifyItem->tnlInformation;
8876 tnlUsage = &connectionModifyItem->tnlUsage;
8880 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8882 connectionRemoveITem = (E2connectionSetupFailed_Item_t*)connectionInfo;
8883 tnlInformation= &connectionRemoveITem->tnlInformation;
8884 cause = &connectionRemoveITem->cause;
8891 tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
8892 DU_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
8893 if(!tnlInformation->tnlAddress.buf)
8895 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8899 tnlInformation->tnlAddress.buf[3] = ipAddress & 0xFF;
8900 tnlInformation->tnlAddress.buf[2] = (ipAddress>> 8) & 0xFF;
8901 tnlInformation->tnlAddress.buf[1] = (ipAddress>> 16) & 0xFF;
8902 tnlInformation->tnlAddress.buf[0] = (ipAddress>> 24) & 0xFF;
8903 tnlInformation->tnlAddress.bits_unused = 0;
8907 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
8912 case ProtocolIE_IDE2_id_E2connectionSetupFailed_Item:
8914 failureCause.causeType = E2_TRANSPORT;
8915 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
8916 fillE2Cause(cause, failureCause);
8926 /*******************************************************************
8928 * @brief Build E2 connection modification list
8932 * Function :BuildE2ConnectionUpdateList
8934 * Functionality: Build E2 connection modification list
8937 * E2 connection update list to be filled
8938 * Count of E2 connection to be added in the list
8939 * Received list of E2 connection
8941 * @return ROK - success
8943 * ****************************************************************/
8945 uint8_t BuildE2ConnectionUpdateList(E2connectionUpdate_List_t *connectionSetupList, uint8_t count, E2ConnectionItem *tmpConnectionList)
8948 E2connectionUpdate_ItemIEs_t *connectionSetupItem=NULLP;
8950 connectionSetupList->list.count = count;
8952 connectionSetupList->list.size = connectionSetupList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
8953 DU_ALLOC(connectionSetupList->list.array, connectionSetupList->list.size);
8954 if(connectionSetupList->list.array)
8956 for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
8958 DU_ALLOC(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
8959 if(connectionSetupList->list.array[arrIdx] == NULLP)
8961 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8964 connectionSetupItem = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
8965 connectionSetupItem->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
8966 connectionSetupItem->criticality= CriticalityE2_ignore;
8967 connectionSetupItem->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
8968 if(fillE2connectionUpdateItem((PTR)&connectionSetupItem->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item,\
8969 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
8971 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
8979 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
8985 /*******************************************************************
8987 * @brief Build E2 connection setup failed list
8991 * Function : BuildE2ConnectionSetupFailedList
8993 * Functionality: Build E2 connection setup failed list
8996 * E2 connection setup failed list to be filled
8997 * Count of E2 connection to be added in the list
8998 * Received list of E2 connection
9000 * @return ROK - success
9002 * ****************************************************************/
9004 uint8_t BuildE2ConnectionSetupFailedList(E2connectionSetupFailed_List_t *setupFailedList, uint8_t count, E2ConnectionItem *tmpConnectionList)
9007 E2connectionSetupFailed_ItemIEs_t *setupFailedItem=NULLP;
9009 setupFailedList->list.count = 1;
9011 setupFailedList->list.size = setupFailedList->list.count*sizeof(E2connectionSetupFailed_ItemIEs_t *);
9012 DU_ALLOC(setupFailedList->list.array, setupFailedList->list.size);
9013 if(setupFailedList->list.array)
9015 for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
9017 DU_ALLOC(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9018 if(setupFailedList->list.array[arrIdx] == NULLP)
9020 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9023 setupFailedItem = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
9024 setupFailedItem->id = ProtocolIE_IDE2_id_E2connectionSetupFailed_Item;
9025 setupFailedItem->criticality= CriticalityE2_ignore;
9026 setupFailedItem->value.present = E2connectionSetupFailed_ItemIEs__value_PR_E2connectionSetupFailed_Item;
9027 if(fillE2connectionUpdateItem((PTR)&setupFailedItem->value.choice.E2connectionSetupFailed_Item, ProtocolIE_IDE2_id_E2connectionSetupFailed_Item,\
9028 tmpConnectionList[arrIdx].ipV4Addr, tmpConnectionList[arrIdx].usage) != ROK)
9030 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection failed to update item");
9038 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9044 /*******************************************************************
9046 * @brief Deallocate the memory allocated for E2 Connection
9051 * Function :FreeE2ConnectionUpdateAcknowledge
9054 * - freeing the memory allocated for E2 Connection
9057 * @params[in] E2AP_PDU_t *e2apMsg
9058 * @return ROK - success
9061 * ****************************************************************/
9063 void FreeE2ConnectionUpdateAcknowledge(E2AP_PDU_t *e2apMsg)
9065 uint8_t ieIdx =0, arrIdx=0;
9066 E2connectionUpdateAcknowledge_t *connectionUpdate = NULLP;
9067 E2connectionUpdate_List_t *connectionSetupList = NULLP;
9068 E2connectionSetupFailed_List_t *setupFailedList = NULLP;
9070 if(e2apMsg != NULLP)
9072 if(e2apMsg->choice.successfulOutcome != NULLP)
9074 connectionUpdate = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9075 if(connectionUpdate->protocolIEs.list.array)
9077 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9079 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9081 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9083 case ProtocolIE_IDE2_id_TransactionID:
9086 case ProtocolIE_IDE2_id_E2connectionSetup:
9088 connectionSetupList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9089 if(connectionSetupList->list.array)
9091 for(arrIdx = 0; arrIdx < connectionSetupList->list.count; arrIdx++)
9093 DU_FREE(connectionSetupList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
9095 DU_FREE(connectionSetupList->list.array, connectionSetupList->list.size);
9100 case ProtocolIE_IDE2_id_E2connectionSetupFailed:
9102 setupFailedList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
9103 if(setupFailedList->list.array)
9105 for(arrIdx = 0; arrIdx < setupFailedList->list.count; arrIdx++)
9107 DU_FREE(setupFailedList->list.array[arrIdx], sizeof(E2connectionSetupFailed_ItemIEs_t));
9109 DU_FREE(setupFailedList->list.array, setupFailedList->list.size);
9114 DU_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9117 DU_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
9119 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9121 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
9125 /*******************************************************************
9127 * @brief Buld and send the E2 Connection Update Acknowledge msg
9131 * Function : BuildAndSendE2ConnectionUpdateAcknowledge
9134 * - Buld and send the E2 Connection Update Acknowledge Message
9137 * List of E2 connection needs to fill in IE
9138 * @return ROK - success
9141 * ****************************************************************/
9143 uint8_t BuildAndSendE2ConnectionUpdateAcknowledge(uint16_t transId, E2ConnectionList connectionInfoList)
9145 uint8_t ieIdx = 0, elementCnt = 0;
9146 uint8_t ret = RFAILED;
9147 E2AP_PDU_t *e2apMsg = NULLP;
9148 asn_enc_rval_t encRetVal;
9149 E2connectionUpdateAcknowledge_t *e2ConnectionUpdateAcknowledge=NULLP;
9151 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Acknowledge Message\n");
9154 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
9155 if(e2apMsg == NULLP)
9157 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9160 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
9162 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
9163 if(e2apMsg->choice.successfulOutcome == NULLP)
9165 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9169 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
9170 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
9171 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge;
9172 e2ConnectionUpdateAcknowledge = &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge;
9175 if(connectionInfoList.numOfE2ConnectionSetup)
9177 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9180 e2ConnectionUpdateAcknowledge->protocolIEs.list.count = elementCnt;
9181 e2ConnectionUpdateAcknowledge->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdateAck_IEs_t*);
9182 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array, e2ConnectionUpdateAcknowledge->protocolIEs.list.size);
9183 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array)
9185 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9189 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
9191 DU_ALLOC(e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdateAck_IEs_t));
9192 if(!e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx])
9194 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
9198 if(ieIdx < elementCnt)
9202 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
9203 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9204 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_TransactionID;
9205 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
9207 if(connectionInfoList.numOfE2ConnectionSetup)
9210 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetup;
9211 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9212 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionUpdate_List;
9213 if(BuildE2ConnectionUpdateList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List, \
9214 connectionInfoList.numOfE2ConnectionSetup, connectionInfoList.setupE2Connection) != ROK)
9216 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection setup list");
9221 if(connectionInfoList.numOfE2ConnectionFailedToSetup)
9224 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionSetupFailed;
9225 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
9226 e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdateAck_IEs__value_PR_E2connectionSetupFailed_List;
9227 if(BuildE2ConnectionSetupFailedList(&e2ConnectionUpdateAcknowledge->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List, \
9228 connectionInfoList.numOfE2ConnectionFailedToSetup, connectionInfoList.failedToSetupE2Connection) != ROK)
9230 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection failed to setup list");
9235 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
9237 memset(encBuf, 0, ENC_BUF_MAX_LEN);
9239 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
9240 if(encRetVal.encoded == ENCODE_FAIL)
9242 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update acknowledge failure structure (at %s)\n",\
9243 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9248 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update Acknowledge \n");
9249 for(int i=0; i< encBufSize; i++)
9251 DU_LOG("%x",encBuf[i]);
9256 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
9258 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update Acknowledge");
9266 FreeE2ConnectionUpdateAcknowledge(e2apMsg);
9270 /******************************************************************
9272 * @brief Deallocation of memory allocated by aper decoder for
9273 * E2 Connection Update
9277 * Function :freeAperDecodingOfE2ConnectionUpdate
9279 * Functionality: Deallocation of memory allocated by aper decoder for
9280 * E2 Connection Update
9282 * @params[in] Pointer to connectionUpdate
9285 * ****************************************************************/
9287 void freeAperDecodingOfE2ConnectionUpdate(E2connectionUpdate_t *connectionUpdate)
9289 uint8_t ieIdx =0, arrIdx=0;
9290 E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
9291 E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
9293 if(connectionUpdate->protocolIEs.list.array)
9295 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
9297 if(connectionUpdate->protocolIEs.list.array[ieIdx])
9299 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
9301 case ProtocolIE_IDE2_id_TransactionID:
9304 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9306 connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
9307 if(connectionToBeModifyList->list.array)
9309 for(arrIdx= 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
9311 free(connectionToBeModifyList->list.array[arrIdx]);
9313 free(connectionToBeModifyList->list.array);
9317 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9319 connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
9320 if(connectionToBeRemoveList->list.array)
9322 for(arrIdx= 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
9324 free(connectionToBeRemoveList->list.array[arrIdx]);
9326 free(connectionToBeRemoveList->list.array);
9331 free(connectionUpdate->protocolIEs.list.array[ieIdx]);
9334 free(connectionUpdate->protocolIEs.list.array);
9338 /*******************************************************************
9340 * @brief Handling of E2 connection modification Ie
9344 * Function : handleE2ConnectionModification
9346 * Functionality: Handling of E2 connection modification Ie
9349 * E2 Connection update list
9350 * E2 connection list which needs to be filled
9353 ******************************************************************/
9355 void handleE2ConnectionModification(E2connectionUpdate_List_t *connectionUpdateList, E2ConnectionList *connectionInfoList)
9357 uint32_t ipAddress=0;
9358 bool infoFound = false;
9359 uint8_t arrIdx=0,idx=0, count =0;
9360 E2connectionUpdate_ItemIEs_t *connectionModifyItem=NULLP;
9362 if(connectionUpdateList->list.array)
9364 for(arrIdx = 0; arrIdx < connectionUpdateList->list.count; arrIdx++)
9366 connectionModifyItem= (E2connectionUpdate_ItemIEs_t*)connectionUpdateList->list.array[arrIdx];
9367 bitStringToInt(&connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlInformation.tnlAddress, &ipAddress);
9368 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9370 /* If the TNL information is found in the data base, update the
9371 * information in the database */
9372 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9374 duCb.e2apDb.tnlAssoc[idx].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9380 /* If the TNL information is found in the data base, then add the
9381 * information in setupE2Connection array else add in failedToSetupE2Connection array */
9382 if(infoFound == true)
9384 count =connectionInfoList->numOfE2ConnectionSetup;
9385 connectionInfoList->setupE2Connection[count].ipV4Addr = duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr;
9386 connectionInfoList->setupE2Connection[count].usage = duCb.e2apDb.tnlAssoc[idx].usage;
9387 connectionInfoList->numOfE2ConnectionSetup++;
9391 count = connectionInfoList->numOfE2ConnectionFailedToSetup;
9392 connectionInfoList->failedToSetupE2Connection[count].ipV4Addr = ipAddress;
9393 connectionInfoList->failedToSetupE2Connection[count].usage = connectionModifyItem->value.choice.E2connectionUpdate_Item.tnlUsage;
9394 connectionInfoList->numOfE2ConnectionFailedToSetup++;
9401 /*******************************************************************
9403 * @brief Handling of E2 connection removal Ie
9407 * Function : handleE2ConnectionRemoval
9409 * Functionality: Handling of E2 connection removal Ie
9412 * E2 Connection removal List
9415 ******************************************************************/
9417 void handleE2ConnectionRemoval(E2connectionUpdateRemove_List_t *connectionRemovalList)
9419 uint32_t ipAddress=0;
9420 uint8_t arrIdx=0,idx=0;
9421 E2connectionUpdateRemove_ItemIEs_t *connectionRemovalItem=NULLP;
9423 if(connectionRemovalList->list.array)
9425 for(arrIdx = 0; arrIdx < connectionRemovalList->list.count; arrIdx++)
9427 connectionRemovalItem= (E2connectionUpdateRemove_ItemIEs_t*)connectionRemovalList->list.array[arrIdx];
9428 bitStringToInt(&connectionRemovalItem->value.choice.E2connectionUpdateRemove_Item.tnlInformation.tnlAddress, &ipAddress);
9429 for(idx=0; idx<duCb.e2apDb.numOfTNLAssoc; idx++)
9431 if(duCb.e2apDb.tnlAssoc[idx].destIpAddress.ipV4Addr == ipAddress)
9433 cmInetClose(&ricParams.sockFd);
9434 removeE2NodeInformation();
9443 /*******************************************************************
9445 * @brief Process e2 connection update received from RIC
9449 * Function : procE2ConnectionUpdate
9451 * Functionality: Process e2 connection update received from RIC
9453 * @param E2AP_PDU_t *e2apMsg
9456 ******************************************************************/
9458 void procE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
9460 uint8_t arrIdx =0, transId =0;
9461 bool invalidTransId = false, connectionFailedToUpdate=false;
9462 E2FailureCause failureCause;
9463 E2ConnectionList connectionInfoList;
9464 E2connectionUpdate_t *connectionUpdate=NULLP;
9466 DU_LOG("\nINFO --> E2AP : E2 connection update received");
9467 connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
9469 memset(&connectionInfoList, 0, sizeof(E2ConnectionList));
9470 for(arrIdx=0; arrIdx<connectionUpdate->protocolIEs.list.count; arrIdx++)
9472 switch(connectionUpdate->protocolIEs.list.array[arrIdx]->id)
9474 case ProtocolIE_IDE2_id_TransactionID:
9476 transId = connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
9479 failureCause.causeType = E2_PROTOCOL;
9480 failureCause.cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
9481 invalidTransId = true;
9486 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
9488 handleE2ConnectionModification(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdate_List,\
9489 &connectionInfoList);
9490 if((connectionInfoList.numOfE2ConnectionSetup == 0) && (connectionInfoList.numOfE2ConnectionFailedToSetup > 0))
9492 failureCause.causeType = E2_TRANSPORT;
9493 failureCause.cause = E2_TRANSPORT_CAUSE_UNSPECIFIED;
9494 connectionFailedToUpdate =true;
9500 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
9502 handleE2ConnectionRemoval(&connectionUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2connectionUpdateRemove_List);
9508 DU_LOG("\nERROR --> E2AP : Invalid IE received[%ld]",connectionUpdate->protocolIEs.list.array[arrIdx]->id);
9513 if(invalidTransId == true || connectionFailedToUpdate ==true)
9517 if(invalidTransId == true || connectionFailedToUpdate == true)
9519 if(BuildAndSendE2ConnectionUpdateFailure(transId, failureCause) != ROK)
9521 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update failure");
9526 if(BuildAndSendE2ConnectionUpdateAcknowledge(transId, connectionInfoList) != ROK)
9528 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 connection update ack");
9532 freeAperDecodingOfE2ConnectionUpdate(connectionUpdate);
9535 /*******************************************************************
9537 * @brief Free RIC Subscription action to be added list
9541 * Function : freeAperDecodingOfRicSubsActionToBeAdded
9543 * Functionality: Free the RIC Subscription action to be added list
9545 * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
9548 * ****************************************************************/
9549 void freeAperDecodingOfRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
9551 uint8_t elementIdx = 0;
9552 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
9554 if(subsDetails->list.array)
9556 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9558 if(subsDetails->list.array[elementIdx])
9560 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
9561 free(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf);
9562 free(subsDetails->list.array[elementIdx]);
9565 free(subsDetails->list.array);
9569 /*******************************************************************
9571 * @brief Deallocation of memory allocated by aper decoder for
9572 * RIC Subscription action to be removed list
9576 * Function : freeAperDecodingOfRicSubsActionToBeRemoved
9578 * Functionality: Free the RIC Subscription action to be removed list
9580 * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
9583 * ****************************************************************/
9584 void freeAperDecodingOfRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
9586 uint8_t elementIdx = 0;
9588 if(subsDetails->list.array)
9590 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9592 if(subsDetails->list.array[elementIdx])
9594 free(subsDetails->list.array[elementIdx]);
9597 free(subsDetails->list.array);
9601 /*******************************************************************
9603 * @brief Deallocation of memory allocated by aper decoder for
9604 * RIC Subscription action to be modify
9608 * Function : freeAperDecodingOfRicSubsActionToBeModified
9610 * Functionality: Free the RIC Subscription action to be modify
9612 * @params[in] RICactions_ToBeModifiedForModification_List_t List
9615 * ****************************************************************/
9616 void freeAperDecodingOfRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
9618 uint8_t elementIdx = 0;
9619 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
9621 if(subsDetails->list.array)
9623 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
9625 if(subsDetails->list.array[elementIdx])
9627 actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx];
9628 if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
9630 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf);
9631 free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition);
9633 free(subsDetails->list.array[elementIdx]);
9636 free(subsDetails->list.array);
9640 /*******************************************************************
9642 * @brief Deallocation of memory allocated by aper decoder for
9643 * RIC Subscription modification Request
9647 * Function freeAperDecodingOfRicSubsModificationReq
9649 * Functionality : Free RIC Subscription modification Request
9651 * @params[in] E2AP_PDU
9654 ******************************************************************/
9655 void freeAperDecodingOfRicSubsModificationReq(E2AP_PDU_t *e2apRicMsg)
9658 RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
9659 RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe;
9661 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
9663 if(ricSubscriptionModReq->protocolIEs.list.array)
9665 for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
9667 if(ricSubscriptionModReq->protocolIEs.list.array[idx])
9669 ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
9671 switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
9673 case ProtocolIE_IDE2_id_RICrequestID:
9676 case ProtocolIE_IDE2_id_RANfunctionID:
9679 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
9681 freeAperDecodingOfRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
9684 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
9686 freeAperDecodingOfRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
9689 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
9691 freeAperDecodingOfRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
9696 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
9702 free(ricSubscriptionModReq->protocolIEs.list.array[idx]);
9705 free(ricSubscriptionModReq->protocolIEs.list.array);
9708 /*******************************************************************
9710 * @brief Extract RIC Action to be added
9714 * Function : extractRicActionToBeAddedForModification
9716 * Functionality : This function :
9717 * - [Step -1] Traverse each AddedForModification item indexes.
9718 * - [Step -2] Add each action id related information in
9719 * RicSubscription Db.
9720 * - [Step -3] If failed to store then add action related info in
9721 * pending rsp's rejectedActionList.
9722 * - [Step -4] Else increment action added count
9723 * - [Step -5] If there is even 1 action that can be added,
9724 * return ROK, else RFAILED.
9726 * @params[in] RAN Function Database structure
9727 * RIC Subscription Info to be added to RAN function
9728 * RIC Action To Be AddedForModification List received from RIC
9730 * Pending Subs Mod Rsp Info
9731 * @return ROK - success
9734 ******************************************************************/
9735 uint8_t extractRicActionToBeAddedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9736 RICactions_ToBeAddedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9738 uint8_t actionAdded=0;
9739 CmLList *actionNode = NULLP;
9740 uint8_t actionIdx = 0;
9741 uint8_t ricActionId = 0;
9742 RICaction_ToBeAddedForModification_ItemIEs_t *actionItem = NULLP;
9744 if(actionList->list.array)
9746 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9749 actionItem =(RICaction_ToBeAddedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9750 switch(actionItem->id)
9752 case ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item:
9755 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeAddedForModification_Item,\
9756 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item, failureCause);
9761 subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].id = ricActionId;
9762 if(failureCause->causeType == E2_NOTHING)
9764 failureCause->causeType = E2_RIC_REQUEST;
9765 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
9767 memcpy(&subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].failureCause, \
9768 failureCause, sizeof(E2FailureCause));
9769 subsModRsp->addActionStatus.numOfRejectedActions++;
9779 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicAddedForModificationLst:%ld",actionItem->id);
9789 if(failureCause->causeType == E2_NOTHING)
9791 failureCause->causeType = E2_RIC_REQUEST;
9792 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
9797 /*******************************************************************
9799 * @brief Extract RIC Action to be Modified
9803 * Function : extractRicActionToBeModifiedForModification
9805 * Functionality : This function :
9806 * - [Step -1] Traverse each Modification item indexes.
9807 * - [Step -2] Find each action id related information in
9808 * RicSubscription Db.
9809 * - [Step -3] If not found store the action related info in pending
9810 * rsp's action rejected.
9811 * - [Step -4] If found store the new node in action seq list.
9812 * [Step -4.1] If action failed to store, add the action
9813 * info in pending subscription rsp's rejected list.
9814 * [Step -4.2] If action stored successfully, change the status
9815 * of added action to modified because action added as part of
9816 * ric subscription modification req.
9817 * - [Step -5] If there is even 1 action that can be modified,
9818 * return ROK, else RFAILED.
9820 * @params[in] RAN Function Database structure
9821 * RIC Subscription Info to be Modified to RAN function
9822 * RIC Action To Be ModifiedForModification List received from RIC
9824 * Pending Subs Mod Rsp Info
9825 * @return ROK - success
9828 ******************************************************************/
9829 uint8_t extractRicActionToBeModifiedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9830 RICactions_ToBeModifiedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9833 uint8_t actionIdx = 0;
9834 uint8_t actionFound=0;
9835 CmLList *actionNode = NULLP;
9836 ActionInfo *actionDb = NULLP;
9837 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
9839 if(actionList->list.array)
9841 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9844 actionItem =(RICaction_ToBeModifiedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9845 switch(actionItem->id)
9847 case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item:
9850 actionId=actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID;
9851 actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
9855 subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionDb->actionId;
9856 failureCause->causeType = E2_RIC_REQUEST;
9857 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
9858 memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \
9859 failureCause, sizeof(E2FailureCause));
9860 subsModRsp->modActionStatus.numOfRejectedActions++;
9866 actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeModifiedForModification_Item,\
9867 &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item, failureCause);
9872 subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionId;
9873 if(failureCause->causeType == E2_NOTHING)
9875 failureCause->causeType = E2_RIC_REQUEST;
9876 failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
9878 memcpy(&subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \
9879 failureCause, sizeof(E2FailureCause));
9880 subsModRsp->addActionStatus.numOfRejectedActions++;
9885 actionDb = (ActionInfo*)actionNode->node;
9886 actionDb->action=CONFIG_MOD;
9894 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicModifiedForModificationLst:%ld",actionItem->id);
9907 /*******************************************************************
9909 * @brief Extract RIC Action to be Removed
9913 * Function : extractRicActionToBeRemovedForModification
9915 * Functionality : This function :
9916 * - [Step -1] Traverse each RemovedForModification item indexes.
9917 * - [Step -2] Find each action id related information in
9918 * RicSubscription Db.
9919 * - [Step -3] If not found store the action related info in pending
9920 * rsp's rejectedActionList.
9921 * - [Step -4] If found mark action's status CONFIG_DEL.
9922 * - [Step -5] If there is even 1 action that can be Removed,
9923 * return ROK, else RFAILED.
9925 * @params[in] RAN Function Database structure
9926 * RIC Subscription Info to be Removed to RAN function
9927 * RIC Action To Be RemovedForModification List received from RIC
9929 * Pending ric subs mod Rsp Info to store failure result
9930 * @return ROK - success
9933 ******************************************************************/
9934 uint8_t extractRicActionToBeRemovedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
9935 RICactions_ToBeRemovedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
9938 uint8_t actionIdx = 0;
9939 uint8_t actionFound=0;
9940 CmLList *actionNode = NULLP;
9941 ActionInfo *actionDb = NULLP;
9942 RICaction_ToBeRemovedForModification_ItemIEs_t *actionItem = NULLP;
9944 if(actionList->list.array)
9946 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
9949 actionItem =(RICaction_ToBeRemovedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
9950 switch(actionItem->id)
9952 case ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item:
9955 actionId = actionItem->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID;
9956 actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
9960 subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].id = actionDb->actionId;
9961 if(failureCause->causeType == E2_NOTHING)
9963 failureCause->causeType = E2_RIC_REQUEST;
9964 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
9966 memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].failureCause, \
9967 failureCause, sizeof(E2FailureCause));
9968 subsModRsp->removeActionStatus.numOfRejectedActions++;
9973 actionDb->action=CONFIG_DEL;
9979 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicRemovedForModificationLst:%ld",actionItem->id);
9992 /*******************************************************************
9994 * @brief Process RIC Subscription modification request
9998 * Function : procRicSubscriptionModificationRequest
10000 * Functionality: Process RIC subscription modification request.
10002 * @params[in] E2AP PDU
10005 ******************************************************************/
10006 void procRicSubscriptionModificationRequest(E2AP_PDU_t *e2apMsg)
10009 uint16_t ranFuncId = 0;
10010 RicRequestId ricReqId;
10011 E2FailureCause failureCause;
10012 bool procFailure = false;
10013 bool addActionIeProcessed=false;
10014 bool modActionIeProcessed =false;
10015 bool removeActionIeProcessed =false;
10016 CmLList *ricSubsNode = NULLP;
10017 RanFunction *ranFuncDb = NULLP;
10018 RicSubscription *ricSubsDb = NULLP;
10019 RICsubscriptionModificationRequest_t *ricSubsModifyReq = NULLP;
10020 RICsubscriptionModificationRequest_IEs_t *ricSubsModifyReqIe = NULLP;
10022 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Request", __func__);
10027 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
10031 if(!e2apMsg->choice.initiatingMessage)
10033 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
10037 ricSubsModifyReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
10038 for(ieIdx = 0; ieIdx < ricSubsModifyReq->protocolIEs.list.count; ieIdx++)
10040 if(!ricSubsModifyReq->protocolIEs.list.array[ieIdx])
10042 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
10046 ricSubsModifyReqIe = ricSubsModifyReq->protocolIEs.list.array[ieIdx];
10047 switch(ricSubsModifyReqIe->id)
10049 case ProtocolIE_IDE2_id_RICrequestID:
10051 memset(&ricReqId, 0, sizeof(RicRequestId));
10052 ricReqId.requestorId = ricSubsModifyReqIe->value.choice.RICrequestID.ricRequestorID;
10053 ricReqId.instanceId = ricSubsModifyReqIe->value.choice.RICrequestID.ricInstanceID;
10057 case ProtocolIE_IDE2_id_RANfunctionID:
10059 ranFuncId = ricSubsModifyReqIe->value.choice.RANfunctionID;
10060 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
10063 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
10064 procFailure = true;
10068 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
10071 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
10072 __func__, ricReqId.requestorId, ricReqId.instanceId);
10073 procFailure = true;
10076 memset(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp], 0, sizeof(PendingSubsModRspInfo));
10077 memcpy(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].requestId,
10078 &ricReqId, sizeof(RicRequestId));
10079 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].ranFuncId = ranFuncId;
10083 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
10085 if(extractRicActionToBeRemovedForModification(ranFuncDb, ricSubsDb,\
10086 &ricSubsModifyReqIe->value.choice.RICactions_ToBeRemovedForModification_List,\
10087 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10089 removeActionIeProcessed= true;
10094 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
10096 if(extractRicActionToBeModifiedForModification(ranFuncDb, ricSubsDb,\
10097 &ricSubsModifyReqIe->value.choice.RICactions_ToBeModifiedForModification_List,\
10098 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10100 modActionIeProcessed = true;
10104 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
10106 if(extractRicActionToBeAddedForModification(ranFuncDb, ricSubsDb,\
10107 &ricSubsModifyReqIe->value.choice.RICactions_ToBeAddedForModification_List,\
10108 &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
10110 addActionIeProcessed = true;
10116 } /* End of switch for Protocol IE Id */
10120 } /* End of for loop for Protocol IE list */
10125 if(!removeActionIeProcessed && !addActionIeProcessed && !modActionIeProcessed)
10127 BuildAndSendRicSubscriptionModificationFailure(ranFuncId, ricReqId, failureCause);
10131 ricSubsDb->action = CONFIG_MOD;
10132 ranFuncDb->numPendingSubsModRsp++;
10134 /*If the remove-action ie is present, send a stats delete request;
10135 * otherwise, change removeActionCompleted to true in the pendingSubsModRspInfo. */
10136 if(removeActionIeProcessed)
10138 BuildAndSendStatsDeleteReq(ricSubsDb, false);
10142 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].removeActionCompleted = true;
10145 /*If the mod-action ie is present, send a stats modification request;
10146 * otherwise, change modActionCompleted to true in the pendingSubsModRspInfo. */
10147 if(modActionIeProcessed)
10149 BuildAndSendStatsModificationReq(ricSubsDb);
10153 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].modActionCompleted= true;
10156 /*If the add-action ie is present, send a stats add request;
10157 * otherwise, change addActionCompleted to true in the pendingSubsModRspInfo. */
10158 if(addActionIeProcessed)
10160 BuildAndSendStatsReq(ricSubsDb);
10164 ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].addActionCompleted= true;
10169 freeAperDecodingOfRicSubsModificationReq(e2apMsg);
10172 /*******************************************************************
10173 * @brief Free RIC Subscription Modification Failure Message
10177 * Function : FreeRicSubscriptionModificationFailure
10179 * Functionality: Free RIC Subscription Modification Failure
10181 * @param E2AP Message PDU
10184 ******************************************************************/
10185 void FreeRicSubscriptionModificationFailure(E2AP_PDU_t *e2apMsg)
10188 RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
10192 if(e2apMsg->choice.unsuccessfulOutcome)
10194 ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
10195 if(ricSubsModFailure->protocolIEs.list.array)
10197 for(ieIdx = 0; ieIdx < ricSubsModFailure->protocolIEs.list.count; ieIdx++)
10199 DU_FREE(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
10201 DU_FREE(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
10203 DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
10205 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
10208 /*******************************************************************
10210 * @brief Builds and Send RIC Subscription Modification Failure
10214 * Function : BuildAndSendRicSubscriptionModificationFailure
10216 * Functionality: Build and send RIC Subscription Modification Failure.
10222 * @return ROK - success
10223 * RFAILED - failure
10225 ******************************************************************/
10226 uint8_t BuildAndSendRicSubscriptionModificationFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
10228 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
10229 E2AP_PDU_t *e2apMsg = NULLP;
10230 RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
10231 RICsubscriptionModificationFailure_IEs_t *ricSubsModFailureIe = NULLP;
10232 asn_enc_rval_t encRetVal; /* Encoder return value */
10236 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Failure Message\n");
10238 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
10239 if(e2apMsg == NULLP)
10241 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10245 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
10246 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
10247 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
10249 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
10252 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
10253 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
10254 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure;
10257 ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
10260 ricSubsModFailure->protocolIEs.list.count = elementCnt;
10261 ricSubsModFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationFailure_IEs_t *);
10263 DU_ALLOC(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
10264 if(ricSubsModFailure->protocolIEs.list.array == NULLP)
10266 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
10270 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
10272 DU_ALLOC(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
10273 if(ricSubsModFailure->protocolIEs.list.array[ieIdx] == NULLP)
10275 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
10276 __func__, ieIdx, __LINE__);
10280 if(ieIdx < elementCnt)
10284 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10285 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
10286 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10287 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RICrequestID;
10288 ricSubsModFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
10289 ricSubsModFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
10292 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10293 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
10294 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10295 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RANfunctionID;
10296 ricSubsModFailureIe->value.choice.RANfunctionID = ranFuncId;
10299 ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
10300 ricSubsModFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
10301 ricSubsModFailureIe->criticality = CriticalityE2_reject;
10302 ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_CauseE2;
10303 fillE2Cause(&ricSubsModFailureIe->value.choice.CauseE2, failureCause);
10305 /* Prints the Msg formed */
10306 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
10307 memset(encBuf, 0, ENC_BUF_MAX_LEN);
10309 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
10310 if(encRetVal.encoded == ENCODE_FAIL)
10312 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Failure Message (at %s)\n",\
10313 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10318 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Failure Message \n");
10319 #ifdef DEBUG_ASN_PRINT
10320 for(int i=0; i< encBufSize; i++)
10322 printf("%x",encBuf[i]);
10327 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
10329 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Failure Message");
10337 FreeRicSubscriptionModificationFailure(e2apMsg);
10341 /*******************************************************************
10343 * @brief Handles received E2AP message and sends back response
10347 * Function : E2APMsgHdlr
10350 * - Decodes received E2AP control message
10351 * - Prepares response message, encodes and sends to SCTP
10354 * @return ROK - success
10355 * RFAILED - failure
10357 * ****************************************************************/
10358 void E2APMsgHdlr(Buffer *mBuf)
10361 char *recvBuf = NULLP;
10363 MsgLen recvBufLen =0;
10364 E2AP_PDU_t *e2apMsg = NULLP;
10365 asn_dec_rval_t rval ={0}; /* Decoder return value */
10366 E2AP_PDU_t e2apasnmsg={0} ;
10368 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
10369 ODU_PRINT_MSG(mBuf, 0,0);
10371 /* Copy mBuf into char array to decode it */
10372 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
10373 DU_ALLOC(recvBuf, (Size)recvBufLen);
10375 if(recvBuf == NULLP)
10377 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
10380 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
10382 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
10386 #ifdef DEBUG_ASN_PRINT
10387 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
10388 for(i=0; i< recvBufLen; i++)
10390 printf("%x",recvBuf[i]);
10394 /* Decoding flat buffer into E2AP messsage */
10395 e2apMsg = &e2apasnmsg;
10396 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
10398 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
10399 DU_FREE(recvBuf, (Size)recvBufLen);
10401 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10403 DU_LOG("\nERROR --> E2AP : ASN decode failed");
10407 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
10409 switch(e2apMsg->present)
10411 case E2AP_PDU_PR_unsuccessfulOutcome:
10413 switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
10415 case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
10417 procE2SetupFailure(e2apMsg);
10420 case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure:
10422 procE2NodeConfigUpdateFailure(e2apMsg);
10425 case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure:
10427 procRicServiceUpdateFailure(e2apMsg);
10430 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse:
10432 procRicSubscriptionModificationRefuse(e2apMsg);
10435 case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
10437 ProcE2RemovalFailure(e2apMsg);
10442 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
10443 e2apMsg->choice.unsuccessfulOutcome->value.present);
10447 free(e2apMsg->choice.unsuccessfulOutcome);
10450 case E2AP_PDU_PR_successfulOutcome:
10452 switch(e2apMsg->choice.successfulOutcome->value.present)
10454 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
10458 procE2SetupRsp(e2apMsg);
10462 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
10464 procResetResponse(e2apMsg);
10467 case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge:
10469 procRicServiceUpdateAck(e2apMsg);
10472 case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm:
10474 procRicSubscriptionModificationConfirm(e2apMsg);
10477 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
10479 procE2NodeConfigUpdateAck(e2apMsg);
10482 case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
10484 ProcE2RemovalResponse(e2apMsg);
10489 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
10490 e2apMsg->choice.successfulOutcome->value.present);
10493 }/* End of switch(successfulOutcome) */
10494 free(e2apMsg->choice.successfulOutcome);
10498 case E2AP_PDU_PR_initiatingMessage:
10500 switch(e2apMsg->choice.initiatingMessage->value.present)
10502 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
10504 procRicSubscriptionRequest(e2apMsg);
10507 case InitiatingMessageE2__value_PR_RICserviceQuery:
10509 procRicServiceQuery(e2apMsg);
10512 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
10514 DU_LOG("\nINFO --> E2AP : Error indication received");
10517 case InitiatingMessageE2__value_PR_ResetRequestE2:
10519 DU_LOG("\nINFO --> E2AP : Reset request received");
10520 procE2ResetRequest(e2apMsg);
10523 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest:
10525 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Request received");
10526 procRicSubscriptionDeleteRequest(e2apMsg);
10529 case InitiatingMessageE2__value_PR_E2RemovalRequest:
10531 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
10532 procE2RemovalRequest(e2apMsg);
10535 case InitiatingMessageE2__value_PR_E2connectionUpdate:
10537 DU_LOG("\nINFO --> E2AP : E2 coneection update received");
10538 procE2ConnectionUpdate(e2apMsg);
10541 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest:
10543 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Request received");
10544 procRicSubscriptionModificationRequest(e2apMsg);
10549 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
10550 e2apMsg->choice.initiatingMessage->value.present);
10553 }/* End of switch(initiatingMessage) */
10554 free(e2apMsg->choice.initiatingMessage);
10559 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
10564 }/* End of switch(e2apMsg->present) */
10566 } /* End of E2APMsgHdlr */
10568 /**********************************************************************
10570 **********************************************************************/