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 *******************************************************************************/
19 /* This file contains E2AP message handler functions */
20 #include "common_def.h"
21 #include "OCTET_STRING.h"
22 #include "BIT_STRING.h"
23 #include "odu_common_codec.h"
24 #include "ric_stub_sctp.h"
26 #include "ric_e2ap_msg_hdl.h"
27 #include "GlobalE2node-gNB-ID.h"
28 #include "ProtocolIE-FieldE2.h"
29 #include "InitiatingMessageE2.h"
30 #include "SuccessfulOutcomeE2.h"
31 #include "UnsuccessfulOutcomeE2.h"
34 #include "E2nodeComponentInterfaceF1.h"
35 #include "E2SM-KPM-RANfunction-Description.h"
36 #include "RANfunction-Name.h"
37 #include "RIC-EventTriggerStyle-Item.h"
38 #include "RIC-ReportStyle-Item.h"
39 #include "MeasurementInfo-Action-Item.h"
40 #include "MeasurementInfoItem.h"
41 #include "E2SM-KPM-ActionDefinition-Format1.h"
42 #include "E2SM-KPM-ActionDefinition.h"
43 #include "E2SM-KPM-EventTriggerDefinition-Format1.h"
44 #include "E2SM-KPM-EventTriggerDefinition.h"
45 #include "E2connectionUpdate-Item.h"
47 /*******************************************************************
49 * @brief Printing Type and Cause of failure
53 * Function : printE2ErrorCause
55 * Functionality: Printing Type and Cause of failure
57 * @params[in] E2 Cause
60 ******************************************************************/
62 void printE2ErrorCause(CauseE2_t *cause)
64 switch(cause->present)
66 case CauseE2_PR_ricRequest:
68 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Request", cause->choice.ricRequest);
71 case CauseE2_PR_ricService:
73 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Service", cause->choice.ricService);
76 case CauseE2_PR_e2Node:
78 DU_LOG("Failure_Type [%s] Cause [%ld]", "E2_Node", cause->choice.e2Node);
81 case CauseE2_PR_transport:
83 DU_LOG("Failure_Type [%s] Cause [%ld]", "Transport", cause->choice.transport);
86 case CauseE2_PR_protocol:
88 DU_LOG("Failure_Type [%s] Cause [%ld]", "Protocol", cause->choice.protocol);
93 DU_LOG("Failure_Type [%s] Cause [%ld]", "Miscellaneous", cause->choice.misc);
98 DU_LOG("Failure_Type and Cause unknown");
104 /*******************************************************************
106 * @brief fill E2 failure cause
110 * Function : fillE2FailureCause
112 * Functionality: fill E2 failure cause
113 * @return ROK - success
116 ******************************************************************/
118 void fillE2FailureCause(CauseE2_t *cause, CauseE2_PR causePresent, uint8_t reason)
120 cause->present = causePresent;
122 switch(cause->present)
124 case CauseE2_PR_ricRequest:
125 cause->choice.ricRequest = reason;
127 case CauseE2_PR_ricService:
128 cause->choice.ricService = reason;
130 case CauseE2_PR_e2Node:
131 cause->choice.e2Node = reason;
133 case CauseE2_PR_transport:
134 cause->choice.transport = reason;
136 case CauseE2_PR_protocol:
137 cause->choice.protocol = reason;
139 case CauseE2_PR_misc:
140 cause->choice.misc = reason;
143 cause->choice.misc = CauseE2Misc_unspecified;
148 /*******************************************************************
150 * @brief Assigns new transaction id to RIC initiated procedure
154 * Function : assignTransactionId
156 * Functionality: Assigns new transaction id to a RIC initiated
159 * @params[in] Region region
161 * @return ROK - success
164 * ****************************************************************/
166 uint8_t assignTransactionId(DuDb *duDb)
168 uint8_t currTransId = duDb->ricTransIdCounter;
170 /* Update to next valid value */
171 duDb->ricTransIdCounter++;
172 if(duDb->ricTransIdCounter == MAX_NUM_TRANSACTION)
173 duDb->ricTransIdCounter = 0;
178 /*******************************************************************
180 * @brief add RIC Subs action info
184 * Function : addRicSubsAction
186 * Functionality: add Ric Subs action info
191 * @return ROK - success
194 ******************************************************************/
195 CmLList *addRicSubsAction(uint8_t ricActionID, CmLListCp *actionSequence)
197 ActionInfo *actionDb = NULLP;
198 CmLList *actionNode=NULLP;
200 RIC_ALLOC(actionDb, sizeof(ActionInfo));
203 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
207 actionDb->actionId = ricActionID;
208 RIC_ALLOC(actionNode, sizeof(CmLList));
211 actionNode->node = (PTR) actionDb;
212 cmLListAdd2Tail(actionSequence, actionNode);
216 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
217 RIC_FREE(actionDb, sizeof(ActionInfo));
224 /*******************************************************************
226 * @brief Sends E2 msg over SCTP
230 * Function : SendE2APMsg
232 * Functionality: Sends E2 msg over SCTP
234 * @params[in] Region region
236 * @return ROK - success
239 * ****************************************************************/
241 uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId)
245 if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
247 if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
249 ODU_PRINT_MSG(mBuf, 0,0);
251 if(sctpSend(duId, mBuf) != ROK)
253 DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
254 ODU_PUT_MSG_BUF(mBuf);
260 DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
261 ODU_PUT_MSG_BUF(mBuf);
264 ODU_PUT_MSG_BUF(mBuf);
268 DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
275 /*******************************************************************
277 * @brief Deallocate the memory allocated for RemovalRequest msg
281 * Function : FreeRemovalRequest
284 * - freeing the memory allocated for RemovalRequest
286 * @params[in] E2AP_PDU_t *e2apMsg
287 * @return ROK - success
290 * ****************************************************************/
291 void FreeRemovalRequest(E2AP_PDU_t *e2apMsg)
294 E2RemovalRequest_t *removalReq = NULLP;
298 if(e2apMsg->choice.initiatingMessage != NULLP)
300 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
301 if(removalReq->protocolIEs.list.array)
303 for(ieIdx = 0; ieIdx < removalReq->protocolIEs.list.count; ieIdx++)
305 RIC_FREE(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
307 RIC_FREE(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
309 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
311 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
315 /*******************************************************************
317 * @brief Build and send the removal request msg
321 * Function : BuildAndSendRemovalRequest
324 * - Buld and send the removal request msg to E2 node
330 * @return ROK - success
333 * ****************************************************************/
334 uint8_t BuildAndSendRemovalRequest(DuDb *duDb)
336 uint8_t ieIdx = 0, elementCnt = 0;
337 uint16_t transId = 0;
338 uint8_t ret = RFAILED;
339 E2AP_PDU_t *e2apMsg = NULLP;
340 E2RemovalRequest_t *removalReq = NULLP;
341 asn_enc_rval_t encRetVal; /* Encoder return value */
343 DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
347 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
350 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
354 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
355 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
356 if(e2apMsg->choice.initiatingMessage == NULLP)
358 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
362 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2removal;
363 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
364 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2RemovalRequest;
365 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
368 removalReq->protocolIEs.list.count = elementCnt;
369 removalReq->protocolIEs.list.size = elementCnt * sizeof(E2RemovalRequestIEs_t *);
371 RIC_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
372 if(!removalReq->protocolIEs.list.array)
374 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
378 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
380 RIC_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
381 if(!removalReq->protocolIEs.list.array[ieIdx])
383 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
388 /* In case of failure */
389 if(ieIdx < elementCnt)
393 removalReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
394 removalReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
395 removalReq->protocolIEs.list.array[ieIdx]->value.present = E2RemovalRequestIEs__value_PR_TransactionID;
396 transId = assignTransactionId(duDb);
397 removalReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
399 /* Prints the Msg formed */
400 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
402 memset(encBuf, 0, ENC_BUF_MAX_LEN);
404 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
406 if(encRetVal.encoded == ENCODE_FAIL)
408 DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
409 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
414 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
415 #ifdef DEBUG_ASN_PRINT
416 for(int i=0; i< encBufSize; i++)
418 printf("%x",encBuf[i]);
422 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
424 DU_LOG("\nERROR --> E2AP : Sending removal request failed");
433 /* Free all memory */
434 FreeRemovalRequest(e2apMsg);
438 /*******************************************************************
440 * @brief Fetches RAN Function DB
444 * Function : fetchRanFuncFromRanFuncId
446 * Functionality: Fetches RAN function DB from E2AP DB using
449 * @params[in] RAN Function ID
450 * @return RAN Function DB
451 * NULL, in case of failure
453 * ****************************************************************/
454 RanFunction *fetchRanFuncFromRanFuncId(DuDb *duDb, uint16_t ranFuncId)
456 RanFunction *ranFuncDb = NULLP;
458 /* Fetch RAN Function DB */
459 if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
461 ranFuncDb = &duDb->ranFunction[ranFuncId-1];
465 DU_LOG("\nERROR --> DU_APP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId);
471 /*******************************************************************
473 * @brief Fetch subscripton DB
477 * Function : fetchSubsInfoFromRicReqId
479 * Functionality: Fetches subscription DB from RAN Function DB
480 * using RIC Request ID
482 * @params[in] RIC Request ID
484 * Pointer to RIC Subscription node to be searched
485 * @return RIC Subscription from RAN Function's subcription list
486 * NULL, in case of failure
488 * ****************************************************************/
489 RicSubscription *fetchSubsInfoFromRicReqId(RicRequestId ricReqId, RanFunction *ranFuncDb, CmLList **ricSubscriptionNode)
491 RicSubscription *ricSubscriptionInfo = NULLP;
493 /* Fetch subscription detail in RAN Function DB */
494 CM_LLIST_FIRST_NODE(&ranFuncDb->subscriptionList, *ricSubscriptionNode);
495 while(*ricSubscriptionNode)
497 ricSubscriptionInfo = (RicSubscription *)((*ricSubscriptionNode)->node);
498 if(ricSubscriptionInfo && (ricSubscriptionInfo->requestId.requestorId == ricReqId.requestorId) &&
499 (ricSubscriptionInfo->requestId.instanceId == ricReqId.instanceId))
503 *ricSubscriptionNode = (*ricSubscriptionNode)->next;
504 ricSubscriptionInfo = NULLP;
507 if(!ricSubscriptionInfo)
509 DU_LOG("\nERROR --> E2AP : fetchSubsInfoFromRicReqId: Subscription not found for Requestor ID [%d] \
510 Instance ID [%d] in RAN Function ID [%d]", ricReqId.requestorId, ricReqId.instanceId, ranFuncDb->id);
513 return ricSubscriptionInfo;
516 /*******************************************************************
518 * @brief Fetch Action details
522 * Function : fetchActionInfoFromActionId
524 * Functionality: Fetch action details from RIC subscription DB
527 * @params[in] Action ID
528 * RIC Subscription DB
530 * @return Action Info DB
531 * NULL, in case of failure
533 * ****************************************************************/
534 ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo, CmLList ** actionNode)
536 ActionInfo *actionInfoDb = NULLP;
538 CM_LLIST_FIRST_NODE(&ricSubscriptionInfo->actionSequence, *actionNode);
541 actionInfoDb = (ActionInfo*)((*actionNode)->node);
542 if(actionInfoDb->actionId == actionId)
546 *actionNode= (*actionNode)->next;
548 if(actionInfoDb==NULLP)
550 DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
551 subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
552 ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
558 /******************************************************************
560 * @brief Search E2 node component with the help of interface type
565 * Function : fetchE2NodeComponentInfo
567 * Functionality: Search E2 node component
572 * Pointer to E2 component node to be searched
575 * ****************************************************************/
577 E2NodeComponent *fetchE2NodeComponentInfo(DuDb *duDb, InterfaceType interfaceType,CmLList **e2ComponentNode)
579 E2NodeComponent *e2NodeComponentInfo=NULLP;
581 if(duDb->e2NodeComponent.count)
583 CM_LLIST_FIRST_NODE(&duDb->e2NodeComponent, *e2ComponentNode);
584 while(*e2ComponentNode)
586 e2NodeComponentInfo = (E2NodeComponent*)((*e2ComponentNode)->node);
587 if((e2NodeComponentInfo->interfaceType == interfaceType))
592 *e2ComponentNode = (*e2ComponentNode)->next;
593 e2NodeComponentInfo = NULLP;
596 return e2NodeComponentInfo;
599 /*******************************************************************
601 * @brief update E2 node config list
605 * Function : updateE2NodeConfigList
608 * - update E2 node config list
612 * Configuration which need to update in Database
614 * @return ROK - success
617 * ****************************************************************/
618 uint8_t updateE2NodeConfigList(DuDb **duDb, uint8_t protocolId, E2NodeConfigItem *tmpCfg)
621 E2NodeComponent * e2NodeComponentInfo;
622 bool configFound= false;
626 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
628 /* Adding the new e2 node component in DB*/
629 RIC_ALLOC(e2NodeComponentInfo, sizeof(E2NodeComponent));
630 e2NodeComponentInfo->interfaceType = tmpCfg->componentInfo.interfaceType;
631 e2NodeComponentInfo->componentId =tmpCfg->componentInfo.componentId;
632 RIC_ALLOC(node, sizeof(CmLList));
635 node->node = (PTR) e2NodeComponentInfo;
636 cmLListAdd2Tail(&(*duDb)->e2NodeComponent, node);
641 DU_LOG("\nERROR --> E2AP : Memory allocation failed for e2NodeComponentList node");
642 RIC_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
647 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
649 /* searching for information in a database */
650 e2NodeComponentInfo = fetchE2NodeComponentInfo((*duDb),tmpCfg->componentInfo.interfaceType, &node);
651 if(!e2NodeComponentInfo)
653 DU_LOG("\nERROR --> E2AP : Failed to find the e2 component node");
656 /* If the node is present then update the value */
657 e2NodeComponentInfo->componentId =tmpCfg->componentInfo.componentId;
661 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
663 /* searching for information in a database */
664 e2NodeComponentInfo = fetchE2NodeComponentInfo((*duDb),tmpCfg->componentInfo.interfaceType, &node);
665 if(!e2NodeComponentInfo)
667 DU_LOG("\nERROR --> E2AP : Failed to find the e2 component node");
670 /* Delete the node from the list */
671 e2NodeComponentInfo->componentId = tmpCfg->componentInfo.componentId;
672 cmLListDelFrm(&(*duDb)->e2NodeComponent, node);
673 RIC_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
679 /* If the configuration update was successful, then mark the isSuccessful as
680 * true; otherwise, mark it as false. */
681 if(configFound == true)
682 tmpCfg->isSuccessful = true;
684 tmpCfg->isSuccessful = false;
689 /*******************************************************************
691 * @brief Handling the E2 node configuration depending on the add,
692 * update, or remove configuration type
696 * Function : handleE2NodeComponentAction
699 * - Handling the E2 node configuration depending on the add,
700 * update, or remove configuration type
703 * Pointer to e2NodeCfg which has info
705 * E2NodeConfigItem to be filled
707 * @return ROK - success
710 * ****************************************************************/
712 uint8_t handleE2NodeComponentAction(DuDb *duDb, PTR e2NodeCfg, uint8_t protocolId, E2NodeConfigItem *storeCfg)
714 uint8_t configFound = ROK;
715 E2NodeConfigItem tmpCfg;
716 E2nodeComponentID_t componentId;
717 E2nodeComponentInterfaceType_t interface;
718 E2nodeComponentConfigAddition_Item_t *addCfg=NULL;
719 E2nodeComponentConfigUpdate_Item_t *updateCfg=NULL;
720 E2nodeComponentConfigRemoval_Item_t *removeCfg=NULL;
722 /* fetching the interface and component id information from the e2NodeCfg */
723 memset(storeCfg, 0, sizeof(E2NodeConfigItem));
724 storeCfg->isSuccessful=false;
725 memset(&tmpCfg, 0, sizeof(E2NodeConfigItem));
729 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
731 addCfg = (E2nodeComponentConfigAddition_Item_t *)e2NodeCfg;
732 interface = addCfg->e2nodeComponentInterfaceType;
733 componentId = addCfg->e2nodeComponentID;
736 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
738 updateCfg = (E2nodeComponentConfigUpdate_Item_t *)e2NodeCfg;
739 interface = updateCfg->e2nodeComponentInterfaceType;
740 componentId = updateCfg->e2nodeComponentID;
743 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
745 removeCfg = (E2nodeComponentConfigRemoval_Item_t*)e2NodeCfg;
746 interface = removeCfg->e2nodeComponentInterfaceType;
747 componentId = removeCfg->e2nodeComponentID;
752 /* Storing the information in temporary structure */
753 tmpCfg.componentInfo.interfaceType = interface;
755 switch(componentId.present)
757 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
759 if(componentId.choice.e2nodeComponentInterfaceTypeF1)
761 tmpCfg.componentInfo.componentId = componentId.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
771 /* Updating the database configuration */
772 configFound = updateE2NodeConfigList(&duDb, protocolId, &tmpCfg);
774 memcpy(storeCfg, &tmpCfg,sizeof(E2NodeConfigItem));
779 /*******************************************************************
781 * @brief deallocate memory allocated in E2 Node Config Update Failure
785 * Function : FreeE2ConfigUpdateFail
787 * Functionality: deallocate memory allocated in E2 Node Config Update Failure
789 * @params[in] E2AP_PDU_t *e2apMsg
792 * ****************************************************************/
794 void FreeE2ConfigUpdateFail(E2AP_PDU_t *e2apMsg)
797 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
801 if(e2apMsg->choice.unsuccessfulOutcome)
803 e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
804 if(e2NodeCfgUpdFail->protocolIEs.list.array)
806 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
808 RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateFailure_IEs_t));
810 RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array, e2NodeCfgUpdFail->protocolIEs.list.size);
812 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
814 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
818 /*******************************************************************
820 * @brief Buld and send the E2 Node Config Update failure
824 * Function : BuildAndSendE2NodeConfigUpdateFailure
827 * - Buld and send the E2 Node Config Update failure
828 * @return ROK - success
831 * ****************************************************************/
833 uint8_t BuildAndSendE2NodeConfigUpdateFailure(uint32_t duId, uint16_t transId, uint8_t causeInfo, uint8_t causeReason)
835 E2AP_PDU_t *e2apMsg = NULL;
836 asn_enc_rval_t encRetVal;
838 uint8_t elementCnt=0;
839 bool memAllocFailed = false;
840 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdateFail=NULL;
842 DU_LOG("\nINFO --> E2AP : Building E2 Node Config Update failure\n");
845 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
848 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
851 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
852 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
853 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
855 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
859 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
860 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
861 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure;
862 e2NodeCfgUpdateFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
865 e2NodeCfgUpdateFail->protocolIEs.list.count = elementCnt;
866 e2NodeCfgUpdateFail->protocolIEs.list.size = elementCnt * sizeof(struct E2nodeConfigurationUpdateFailure_IEs *);
868 RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array, e2NodeCfgUpdateFail->protocolIEs.list.size);
869 if(e2NodeCfgUpdateFail->protocolIEs.list.array == NULLP)
871 DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure array failed");
875 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
877 RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx], sizeof(struct E2nodeConfigurationUpdateFailure_IEs));
878 if(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx] == NULLP)
880 DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure IEs failed");
881 memAllocFailed = true;
886 if(memAllocFailed == true)
893 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
894 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
895 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
896 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
899 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
900 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
901 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
902 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = causeInfo;
903 if(causeInfo == CauseE2_PR_e2Node)
904 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.e2Node = causeReason;
906 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.misc = causeReason;
909 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
910 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
911 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
912 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
914 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
915 memset(encBuf, 0, ENC_BUF_MAX_LEN);
917 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
919 /* Check encode results */
920 if(encRetVal.encoded == ENCODE_FAIL)
922 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node Config Update failure structure (at %s)\n",\
923 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
928 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node Config Update Failure\n");
929 for(int i=0; i< encBufSize; i++)
931 DU_LOG("%x",encBuf[i]);
935 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
937 DU_LOG("\nERROR --> E2AP : Sending E2 Node Config Update Failure failed");
943 FreeE2ConfigUpdateFail(e2apMsg);
947 /*******************************************************************
949 * @brief process the E2 node configuration update
953 * Function : ProcE2NodeConfigUpdate
955 * Functionality: Process E2 node configuration update
959 * Pointer to E2nodeConfigurationUpdate
962 ******************************************************************/
964 void ProcE2NodeConfigUpdate(uint32_t duId, E2nodeConfigurationUpdate_t *e2NodeConfigUpdate)
967 E2NodeConfigList tmpE2NodeList;
969 uint8_t ieIdx = 0, duIdx = 0, elementCnt=0;
970 uint16_t transId = 0;
971 E2nodeComponentConfigAddition_List_t *e2NodeAddList=NULL;
972 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe=NULL;
973 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
974 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList=NULLP;
975 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe=NULLP;
976 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULLP;
977 E2nodeComponentConfigRemoval_List_t *e2NodeRemoveList=NULL;
978 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItemIe=NULL;
979 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
981 SEARCH_DU_DB(duIdx, duId, duDb);
984 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
988 memset(&tmpE2NodeList, 0, sizeof(E2NodeConfigList));
989 if(!e2NodeConfigUpdate)
991 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate pointer is null");
994 if(!e2NodeConfigUpdate->protocolIEs.list.array)
996 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate array pointer is null");
1000 elementCnt = e2NodeConfigUpdate->protocolIEs.list.count;
1001 for(ieIdx=0; ieIdx < e2NodeConfigUpdate->protocolIEs.list.count; ieIdx++)
1003 if(!e2NodeConfigUpdate->protocolIEs.list.array[ieIdx])
1005 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate array idx %d pointer is null",arrIdx);
1009 switch(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->id)
1011 case ProtocolIE_IDE2_id_TransactionID:
1013 transId = e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
1014 if(transId < 0 || transId > 255)
1016 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
1022 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1024 e2NodeAddList =&e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigAddition_List;
1025 if(e2NodeAddList->list.array)
1027 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
1029 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
1030 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
1031 /* Storing the E2 node information in DB */
1032 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeAddItem, ProtocolIE_IDE2_id_E2nodeComponentConfigAddition,\
1033 &tmpE2NodeList.addedE2Node[tmpE2NodeList.addedE2NodeCount++]) != ROK)
1035 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1042 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
1044 e2NodeUpdateList =&e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigUpdate_List;
1045 if(e2NodeUpdateList->list.array)
1047 for(arrIdx = 0; arrIdx< e2NodeUpdateList->list.count; arrIdx++)
1049 e2NodeUpdateItemIe = (E2nodeComponentConfigUpdate_ItemIEs_t*) e2NodeUpdateList->list.array[arrIdx];
1050 e2NodeUpdateItem = &e2NodeUpdateItemIe->value.choice.E2nodeComponentConfigUpdate_Item;
1052 /* Updating the E2 node information in DB */
1053 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeUpdateItem, ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate,\
1054 &tmpE2NodeList.updatedE2Node[tmpE2NodeList.updatedE2NodeCount++]) != ROK)
1056 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1063 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
1065 e2NodeRemoveList = &e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigRemoval_List;
1066 if(e2NodeRemoveList->list.array)
1068 for(arrIdx = 0; arrIdx< e2NodeRemoveList->list.count; arrIdx++)
1070 e2NodeRemovalItemIe = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemoveList->list.array[arrIdx];
1071 e2NodeRemovalItem = &e2NodeRemovalItemIe->value.choice.E2nodeComponentConfigRemoval_Item;
1073 /* Removing the E2 node information in DB */
1074 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeRemovalItem, ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval,\
1075 &tmpE2NodeList.removedE2Node[tmpE2NodeList.removedE2NodeCount++]) != ROK)
1077 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1090 /* If all of the IEs are processed successfully, we will send an e2 node
1091 * config update ack message.
1092 * else we will be sendinf e2 node config update failure */
1093 if(elementCnt == ieIdx)
1095 if(BuildAndSendE2NodeConfigUpdateAck(duDb, transId, &tmpE2NodeList) !=ROK)
1097 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 node config ack");
1103 if(BuildAndSendE2NodeConfigUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
1105 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 node config Failure");
1110 /*******************************************************************
1112 * @brief Builds Global RIC Id Params
1116 * Function : BuildGlobalRicId
1118 * Functionality: Building the Plmn and ric id
1120 * @params[in] GlobalRIC_ID_t *ricId
1121 * @return ROK - success
1124 * ****************************************************************/
1126 uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId)
1129 uint8_t byteSize = 3;
1133 ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
1134 RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
1135 buildPlmnId(ricCb.ricCfgParams.plmn , ricId->pLMN_Identity.buf);
1137 ricId->ric_ID.size = byteSize * sizeof(uint8_t);
1138 RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
1139 fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
1144 /*******************************************************************
1146 * @brief deallocate the memory allocated in E2SetupResponse
1150 * Function : FreeE2SetupRsp
1152 * Functionality: deallocate the memory allocated in E2SetupResponse
1154 * @params[in] E2AP_PDU_t *e2apMsg
1157 * ****************************************************************/
1158 void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
1160 uint8_t arrIdx = 0, e2NodeConfigIdx=0, ranFuncIdx=0;
1161 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
1162 E2setupResponse_t *e2SetupRsp=NULL;
1163 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULL;
1164 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULL;
1165 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULL;
1169 if(e2apMsg->choice.successfulOutcome)
1171 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
1172 if(e2SetupRsp->protocolIEs.list.array)
1174 for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
1176 switch(e2SetupRsp->protocolIEs.list.array[arrIdx]->id)
1178 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
1180 ranFuncAcceptedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
1181 if(ranFuncAcceptedList->list.array)
1183 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
1185 if(ranFuncAcceptedList->list.array[ranFuncIdx])
1187 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1190 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
1194 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1196 e2NodeConfigAdditionAckList =&e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
1197 if(e2NodeConfigAdditionAckList->list.count)
1199 for(e2NodeConfigIdx=0; e2NodeConfigIdx<e2NodeConfigAdditionAckList->list.count; e2NodeConfigIdx++)
1201 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2NodeConfigIdx];
1202 if(e2NodeAddAckItemIe)
1204 f1InterfaceInfo = e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
1207 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
1208 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
1210 RIC_FREE(e2NodeAddAckItemIe, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
1213 RIC_FREE(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
1218 RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
1220 RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
1222 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1224 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1228 /*******************************************************************
1230 * @brief fill e2 node configuration for ack msg
1234 * Function : fillE2NodeConfigAck
1237 * - fill e2 node configuration for ack msg
1240 * Pointer to e2NodeCfg to be filled
1242 * E2 Node Component information
1243 * Is successful or failure response
1244 * @return ROK - success
1247 * ****************************************************************/
1249 uint8_t fillE2NodeConfigAck(PTR e2NodeCfg, uint8_t procedureCode, E2NodeComponent *componentInfo, bool isSuccessful)
1251 E2nodeComponentID_t *e2nodeComponentID=NULLP;
1252 E2nodeComponentInterfaceType_t *e2nodeComponentInterfaceType=NULLP;
1253 E2nodeComponentConfigurationAck_t *e2nodeComponentConfigurationAck=NULLP;
1254 E2nodeComponentConfigRemovalAck_Item_t *removalAckItem=NULLP;
1255 E2nodeComponentConfigUpdateAck_Item_t *updateAckItem=NULLP;
1256 E2nodeComponentConfigAdditionAck_Item_t *additionAckItem=NULLP;
1258 /* filling the interface type, component id, configuration ack based on the
1259 * e2 node configuration add, update, delete type */
1260 switch(procedureCode)
1262 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1264 additionAckItem = (E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg;
1265 e2nodeComponentInterfaceType = &((E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg)->e2nodeComponentInterfaceType;
1266 e2nodeComponentID = &additionAckItem->e2nodeComponentID;
1267 e2nodeComponentConfigurationAck = &additionAckItem->e2nodeComponentConfigurationAck;
1270 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
1272 updateAckItem = (E2nodeComponentConfigUpdateAck_Item_t*) e2NodeCfg;
1273 e2nodeComponentInterfaceType = &updateAckItem->e2nodeComponentInterfaceType;
1274 e2nodeComponentID = &updateAckItem->e2nodeComponentID;
1275 e2nodeComponentConfigurationAck = &updateAckItem->e2nodeComponentConfigurationAck;
1278 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
1280 removalAckItem= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
1281 e2nodeComponentInterfaceType = &removalAckItem->e2nodeComponentInterfaceType;
1282 e2nodeComponentID = &removalAckItem->e2nodeComponentID;
1283 e2nodeComponentConfigurationAck = &removalAckItem->e2nodeComponentConfigurationAck;
1288 /* >E2 Node Component interface type */
1289 if(componentInfo->interfaceType>=NG && componentInfo->interfaceType<=X2)
1291 *e2nodeComponentInterfaceType = componentInfo->interfaceType;
1295 DU_LOG("\nERROR --> E2AP: Received an invalid interface value %d",componentInfo->interfaceType);
1299 if(*e2nodeComponentInterfaceType == E2nodeComponentInterfaceType_f1)
1301 /* >E2 Node Component ID */
1302 e2nodeComponentID->present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
1303 RIC_ALLOC(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
1304 if(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
1306 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1309 e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
1310 RIC_ALLOC(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1312 if(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
1314 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1317 e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = componentInfo->componentId;
1322 /* >E2 Node Component Configuration Acknowledge*/
1323 e2nodeComponentConfigurationAck->updateOutcome = E2nodeComponentConfigurationAck__updateOutcome_success;
1327 /* >E2 Node Component Configuration Acknowledge*/
1328 e2nodeComponentConfigurationAck->updateOutcome = E2nodeComponentConfigurationAck__updateOutcome_failure;
1329 RIC_ALLOC(e2nodeComponentConfigurationAck->failureCauseE2, sizeof(struct CauseE2));
1330 if(e2nodeComponentConfigurationAck->failureCauseE2)
1332 fillE2FailureCause(e2nodeComponentConfigurationAck->failureCauseE2, CauseE2_PR_e2Node, CauseE2node_e2node_component_unknown);
1336 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1343 /*******************************************************************
1345 * @brief Build E2node Component config addition ack list
1349 * Function : BuildE2nodeComponentConfigAdditionAck
1351 * Functionality: Build E2node Component config addition ack list
1354 * E2nodeComponentConfigAdditionAck_List to be filled
1355 * Count of e2 node to be added
1356 * list of e2 node cfg to be added
1358 * @return ROK - success
1360 * ****************************************************************/
1362 uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, \
1363 uint16_t addedE2NodeCount, E2NodeConfigItem *addedE2Node)
1365 uint16_t arrIdx = 0;
1366 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULLP;
1368 e2NodeConfigAdditionAckList->list.count = addedE2NodeCount;
1370 e2NodeConfigAdditionAckList->list.size = e2NodeConfigAdditionAckList->list.count * sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t*);
1371 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
1372 if(e2NodeConfigAdditionAckList->list.array == NULLP)
1374 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
1378 for(arrIdx = 0; arrIdx< e2NodeConfigAdditionAckList->list.count; arrIdx++)
1380 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
1381 if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
1383 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
1386 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[arrIdx];
1387 e2NodeAddAckItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
1388 e2NodeAddAckItemIe->criticality = CriticalityE2_reject;
1389 e2NodeAddAckItemIe->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_E2nodeComponentConfigAdditionAck_Item;
1391 /* Filling the e2 node config addition ack item */
1392 fillE2NodeConfigAck((PTR)&e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck,\
1393 &addedE2Node[arrIdx].componentInfo, addedE2Node[arrIdx].isSuccessful);
1398 /*******************************************************************
1400 * @brief Build RAN function accepted list
1404 * Function : BuildRanFunctionAcceptedList
1406 * Functionality: Build RAN function accepted list
1407 * ->For ProcedureCodeE2_id_E2setup or ProcedureCodeE2_id_RICserviceQuery
1408 * we add all the RAN Function list which is present in RIC database.
1409 * ->For any other procedures, we just fill the RAN functions whose ID
1410 * is present in the recvList
1414 * Count of ran functions to be accepted in the list
1415 * Received list of RAN functions
1419 * @return ROK - success
1421 * ****************************************************************/
1423 uint8_t BuildRanFunctionAcceptedList(DuDb *duDb, uint8_t count, RanFunction *ranFunAcceptedList, RANfunctionsID_List_t *ranFuncAcceptedList, uint8_t procedureCode)
1425 uint16_t ranFuncIdx = 0;
1426 RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL;
1428 /* For ProcedureCodeE2_id_E2setup and ProcedureCodeE2_id_RICserviceQuery,
1429 * the number of RAN function list items is equal to the number of
1430 * ran function entries stored in the database.
1431 * For any other procedure, the RAN function list count is equal
1432 * to the count of ran functions obtained from the function's caller */
1434 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
1435 ranFuncAcceptedList->list.count = duDb->numOfRanFunction;
1437 ranFuncAcceptedList->list.count = count;
1439 ranFuncAcceptedList->list.size = ranFuncAcceptedList->list.count*sizeof(RANfunctionID_ItemIEs_t*);
1440 RIC_ALLOC(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
1441 if(ranFuncAcceptedList->list.array)
1443 for(ranFuncIdx = 0; ranFuncIdx< ranFuncAcceptedList->list.count; ranFuncIdx++)
1445 RIC_ALLOC(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1446 if(ranFuncAcceptedList->list.array[ranFuncIdx] == NULLP)
1448 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array item");
1451 ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[ranFuncIdx];
1452 ranFuncAcceptedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
1453 ranFuncAcceptedItemIe->criticality= CriticalityE2_ignore;
1454 ranFuncAcceptedItemIe->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item;
1455 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
1457 /* filling the RAN function information with the help of DuDb */
1458 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = duDb->ranFunction[ranFuncIdx].id;
1459 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= duDb->ranFunction[ranFuncIdx].revisionCounter;
1463 /* filling the the RAN function information with the help received list of RAN functions */
1464 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = ranFunAcceptedList[ranFuncIdx].id;
1465 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= ranFunAcceptedList[ranFuncIdx].revisionCounter;
1471 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array");
1477 /*******************************************************************
1479 * @brief Builds and sends the E2SetupResponse
1483 * Function : BuildAndSendE2SetupRsp
1485 * Functionality: Builds and sends the E2SetupResponse
1490 * List of E2node cofniguration which needs to be send
1492 * @return ROK - success
1495 * ****************************************************************/
1497 uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint16_t transId, E2NodeConfigList e2NodeList)
1499 E2AP_PDU_t *e2apMsg = NULL;
1500 E2setupResponse_t *e2SetupRsp;
1501 asn_enc_rval_t encRetVal;
1504 bool memAllocFailed = false;
1506 DU_LOG("\nINFO --> E2AP : Building E2 Setup Response\n");
1509 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1510 if(e2apMsg == NULLP)
1512 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1515 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1516 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1517 if(e2apMsg->choice.successfulOutcome == NULLP)
1519 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1523 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
1524 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1525 e2apMsg->choice.successfulOutcome->value.present = \
1526 SuccessfulOutcomeE2__value_PR_E2setupResponse;
1527 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
1530 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
1531 if(duDb->numOfRanFunction)
1534 e2SetupRsp->protocolIEs.list.count = elementCnt;
1535 e2SetupRsp->protocolIEs.list.size = elementCnt * sizeof(E2setupResponseIEs_t*);
1537 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
1538 if(e2SetupRsp->protocolIEs.list.array == NULLP)
1540 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
1544 for(idx=0; idx<elementCnt; idx++)
1546 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], sizeof(E2setupResponseIEs_t));
1547 if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
1549 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
1550 memAllocFailed = true;
1555 if(memAllocFailed == true)
1557 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
1562 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_TransactionID;
1563 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1564 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_TransactionID;
1565 e2SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID = transId;
1569 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID;
1570 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1571 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_GlobalRIC_ID;
1573 if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK)
1575 DU_LOG("\nERROR --> E2AP : Failed to build Global Ric Id");
1579 if(duDb->numOfRanFunction)
1581 /* Accepted RAN function Id */
1583 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
1584 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1585 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List;
1586 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_E2setup)!=ROK)
1588 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
1593 /* E2 Node Component Configuration Addition Acknowledge List*/
1595 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
1596 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1597 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
1598 E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List;
1599 if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->\
1600 value.choice.E2nodeComponentConfigAdditionAck_List, e2NodeList.addedE2NodeCount, e2NodeList.addedE2Node) != ROK)
1602 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
1606 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1607 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1609 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1611 /* Check encode results */
1612 if(encRetVal.encoded == ENCODE_FAIL)
1614 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
1615 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1620 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
1621 for(int i=0; i< encBufSize; i++)
1623 DU_LOG("%x",encBuf[i]);
1627 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
1629 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
1635 FreeE2SetupRsp(e2apMsg);
1636 BuildAndSendRicSubscriptionReq(duDb);
1640 /*******************************************************************
1642 * @brief Free RIC Subscription Details
1646 * Function : FreeRicSubsDetails
1648 * Functionality: Free the RIC Subscription Details
1650 * @params[in] RICsubscriptionDetails_t *subsDetails
1653 * ****************************************************************/
1654 void FreeRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
1656 uint8_t elementIdx = 0;
1657 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
1659 RIC_FREE(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size);
1661 if(subsDetails->ricAction_ToBeSetup_List.list.array)
1663 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
1665 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
1667 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
1668 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
1670 RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf, \
1671 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size);
1672 RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
1674 RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t))
1677 RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
1681 /*******************************************************************
1683 * @brief Free RIC Subscription Request
1687 * Function : FreeRicSubscriptionReq
1689 * Functionality : Free RIC Subscription Request
1691 * @return ROK - success
1694 ******************************************************************/
1695 void FreeRicSubscriptionReq(E2AP_PDU_t *e2apRicMsg)
1698 RICsubscriptionRequest_t *ricSubscriptionReq;
1702 if(e2apRicMsg->choice.initiatingMessage)
1704 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
1705 if(ricSubscriptionReq->protocolIEs.list.array)
1707 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
1709 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
1711 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
1713 FreeRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails));
1717 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
1719 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
1721 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1723 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
1727 /*******************************************************************
1729 * @brief Builds Ric Request Id
1733 * Function : BuildNewRicRequestId
1735 * Functionality: Assign new Ric Request ID
1737 * @params[in] RIC request ID to be sent
1738 * RIC request ID stored in DB
1739 * @return ROK - success
1742 * ****************************************************************/
1744 uint8_t BuildNewRicRequestId(RICrequestID_t *ricReqId, RicRequestId *reqIdDb)
1746 static uint16_t requestorId = 0;
1747 static uint16_t instanceId = 0;
1749 if(ricReqId != NULLP)
1751 ricReqId->ricRequestorID = ++requestorId;
1752 ricReqId->ricInstanceID = ++instanceId;
1754 reqIdDb->requestorId = ricReqId->ricRequestorID;
1755 reqIdDb->instanceId = ricReqId->ricInstanceID;
1760 /*******************************************************************
1762 * @brief Free RIC Action Definition
1766 * Function : FreeRicActionDefinition
1768 * Functionality: Free RIC Action Definition
1770 * @params[in] E2SM-KPM Action definition
1773 * ****************************************************************/
1774 void FreeRicActionDefinition(E2SM_KPM_ActionDefinition_t actionDef)
1776 uint8_t elementIdx = 0;
1777 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
1778 MeasurementInfoItem_t *measItem = NULLP;
1780 switch(actionDef.actionDefinition_formats.present)
1782 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
1784 if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1)
1786 actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
1787 if(actionFormat1->measInfoList.list.array)
1789 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
1791 if(actionFormat1->measInfoList.list.array[elementIdx])
1793 measItem = actionFormat1->measInfoList.list.array[elementIdx];
1794 switch(measItem->measType.present)
1796 case MeasurementType_PR_NOTHING:
1797 case MeasurementType_PR_measID:
1799 case MeasurementType_PR_measName:
1801 RIC_FREE(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size)
1805 RIC_FREE(measItem, sizeof(MeasurementInfoItem_t));
1808 RIC_FREE(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
1810 RIC_FREE(actionFormat1, sizeof(E2SM_KPM_ActionDefinition_Format1_t));
1815 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
1816 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
1817 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
1818 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
1819 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_NOTHING:
1824 /*******************************************************************
1826 * @brief Fill RIC Action Definition
1830 * Function : fillRicActionDef
1832 * Functionality: Fill RIC Action Definition
1834 * @params[in] RIC Action definition
1838 * ****************************************************************/
1839 uint8_t fillRicActionDef(RICactionDefinition_t *ricActionDef, uint8_t ricActionId, ConfigType configType)
1841 uint8_t ret = RFAILED;
1842 asn_enc_rval_t encRetVal;
1843 uint8_t elementCnt = 0, elementIdx = 0;
1844 char *measurementTypeName[] = {"RRU.PrbTotDl", "RRU.PrbTotUl"};
1845 E2SM_KPM_ActionDefinition_t actionDef;
1846 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
1847 MeasurementInfoItem_t *measItem = NULLP;
1851 /* Fill E2SM-KPM Action Definition Format 1 */
1853 /* RIC Stype Type */
1854 actionDef.ric_Style_Type = RIC_STYLE_TYPE;
1856 /* RIC Action Definition Format 1 */
1857 actionDef.actionDefinition_formats.present = \
1858 E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1;
1860 RIC_ALLOC(actionDef.actionDefinition_formats.choice.actionDefinition_Format1, \
1861 sizeof(E2SM_KPM_ActionDefinition_Format1_t));
1862 if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1 == NULLP)
1864 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1867 actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
1869 /* Measurement Info List */
1871 actionFormat1->measInfoList.list.count = elementCnt;
1872 actionFormat1->measInfoList.list.size = elementCnt * sizeof(MeasurementInfoItem_t *);
1873 RIC_ALLOC(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
1874 if(actionFormat1->measInfoList.list.array == NULL)
1876 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1880 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
1882 RIC_ALLOC(actionFormat1->measInfoList.list.array[elementIdx], sizeof(MeasurementInfoItem_t));
1883 if(actionFormat1->measInfoList.list.array[elementIdx] == NULLP)
1885 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1889 measItem = actionFormat1->measInfoList.list.array[elementIdx];
1890 measItem->measType.present = MeasurementType_PR_measName;
1892 measItem->measType.choice.measName.size = strlen(measurementTypeName[elementIdx]);
1893 RIC_ALLOC(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size);
1894 if(measItem->measType.choice.measName.buf == NULLP)
1896 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1899 memcpy(measItem->measType.choice.measName.buf, measurementTypeName[elementIdx], measItem->measType.choice.measName.size);
1901 if(elementIdx < elementCnt)
1904 /* Granularity Period */
1905 actionFormat1->granulPeriod = RIC_ACTION_GRANULARITY_PERIOD(configType, ricActionId); /* In ms */
1907 /* Prints the Msg formed */
1908 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, &actionDef);
1910 /* Encode E2SM-KPM RIC Action Definition */
1911 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1913 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_ActionDefinition, 0, &actionDef, PrepFinalEncBuf, encBuf);
1914 if(encRetVal.encoded == ENCODE_FAIL)
1916 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM action definition structure (at %s)\n",\
1917 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1921 /* Copty encoded E2SM-KPM RIC action definition to E2AP octet string buffer */
1922 ricActionDef->size = encBufSize;
1923 RIC_ALLOC(ricActionDef->buf, encBufSize);
1924 if(ricActionDef->buf == NULLP)
1926 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1929 memcpy(ricActionDef->buf, encBuf, encBufSize);
1935 FreeRicActionDefinition(actionDef);
1939 /*******************************************************************
1941 * @brief Fills RIC Action To Be Setup Item
1945 * Function : fillActionToBeSetup
1947 * Functionality: Fill the RIC Action To Be Setup Ite,
1948 * RIC subscription DB
1950 * @params[in] RICaction_ToBeSetup_ItemIEs_t *items
1951 * @return ROK - success
1954 * ****************************************************************/
1955 uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscription *ricSubsDb)
1957 static uint8_t ricActionId = 0;
1958 CmLList *actionNode=NULLP;
1959 if(actionItem == NULLP)
1961 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1967 actionItem->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item;
1968 actionItem->criticality = CriticalityE2_ignore;
1969 actionItem->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
1972 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId;
1973 actionNode = addRicSubsAction(ricActionId, &ricSubsDb->actionSequence);
1976 /* RIC Action Type */
1977 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report;
1979 /* RIC Action Definition */
1980 RIC_ALLOC(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
1981 if(!actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
1983 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1986 if(fillRicActionDef(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, ricActionId, CONFIG_ADD) != ROK)
1988 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1997 cmLListDelFrm(&ricSubsDb->actionSequence, actionNode);
1998 deleteActionSequence(actionNode);
2003 /*******************************************************************
2005 * @brief Free Event Trigger Definition
2009 * Function : FreeEventTriggerDef
2011 * Functionality: Free Event Trigger Definition
2013 * @params[in] E2SM-KPM Event Trigger Definition
2016 * ****************************************************************/
2017 void FreeEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
2021 switch(eventTiggerDef->eventDefinition_formats.present)
2023 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
2025 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
2026 RIC_FREE(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1, \
2027 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
2033 /*******************************************************************
2035 * @brief Fill Event Trigger Definition
2039 * Function : fillEventTriggerDef
2041 * Functionality: Fill Event Trigger Definition
2043 * @params[in] RIC Event Trigger Definition
2047 * ****************************************************************/
2048 uint8_t fillEventTriggerDef(RICeventTriggerDefinition_t *ricEventTriggerDef)
2050 uint8_t ret = RFAILED;
2051 asn_enc_rval_t encRetVal;
2052 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef;
2056 /* Fill E2SM-KPM Event Trigger Definition Format 1 */
2057 eventTiggerDef.eventDefinition_formats.present = \
2058 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1;
2060 RIC_ALLOC(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1, \
2061 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
2062 if(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1 == NULLP)
2064 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2068 eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod = 1000; /* In ms */
2070 /* Prints the Msg formed */
2071 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, &eventTiggerDef);
2073 /* Encode E2SM-KPM Event Trigger Definition */
2074 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2076 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_EventTriggerDefinition, 0, &eventTiggerDef, PrepFinalEncBuf, encBuf);
2077 if(encRetVal.encoded == ENCODE_FAIL)
2079 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM event trigger definition structure (at %s)\n",\
2080 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2084 /* Copy encoded E2SM-KPM event trigger definition to E2AP octet string buffer */
2085 ricEventTriggerDef->size = encBufSize;
2086 RIC_ALLOC(ricEventTriggerDef->buf, encBufSize);
2087 if(ricEventTriggerDef->buf == NULLP)
2089 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2092 memcpy(ricEventTriggerDef->buf, encBuf, encBufSize);
2098 FreeEventTriggerDef(&eventTiggerDef);
2102 /*******************************************************************
2104 * @brief builds RIC Subscription Details
2108 * Function : BuildsRicSubsDetails
2110 * Functionality: Builds the RIC Subscription Details
2112 * @params[in] RIC Subscription details to be filled
2113 * RIC subscriotion DB
2114 * @return ROK - success
2117 * ****************************************************************/
2119 uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails, RicSubscription *ricSubsInfo)
2121 uint8_t elementCnt = 0;
2122 uint8_t elementIdx = 0;
2124 if(subsDetails == NULLP)
2126 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2132 /* RIC Event Trigger Definition */
2133 if(fillEventTriggerDef(&subsDetails->ricEventTriggerDefinition) != ROK)
2135 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2139 /* RIC Actions To Be Setup List */
2141 subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
2142 subsDetails->ricAction_ToBeSetup_List.list.size = elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t *);
2143 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
2144 if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
2146 DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
2150 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
2152 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t));
2153 if(!subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
2155 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2159 if(elementIdx < elementCnt)
2164 if(fillActionToBeSetup((RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], \
2165 ricSubsInfo) != ROK)
2167 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2176 /*******************************************************************
2178 * @brief Builds and Send the RicSubscriptionReq
2182 * Function : BuildAndSendRicSubscriptionReq
2184 * Functionality:Fills the RicSubscriptionReq
2186 * @return ROK - success
2189 ******************************************************************/
2190 uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb)
2192 uint8_t ret = RFAILED;
2193 uint8_t elementCnt = 0;
2195 asn_enc_rval_t encRetVal; /* Encoder return value */
2196 E2AP_PDU_t *e2apRicMsg = NULL;
2197 RICsubscriptionRequest_t *ricSubscriptionReq;
2198 RanFunction *ranFuncDb = &duDb->ranFunction[0];
2199 CmLList *ricSubsNode = NULLP;
2200 RicSubscription *ricSubsInfo = NULLP;
2202 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
2204 /* Allocate memory to store RIC subscription info in RIC DB */
2205 RIC_ALLOC(ricSubsInfo, sizeof(RicSubscription));
2208 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2214 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
2215 if(e2apRicMsg == NULLP)
2217 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2221 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
2222 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2223 if(e2apRicMsg->choice.initiatingMessage == NULLP)
2225 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2228 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
2229 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2230 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
2232 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
2235 ricSubscriptionReq->protocolIEs.list.count = elementCnt;
2236 ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
2238 /* Initialize the subscription members */
2239 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
2240 if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
2242 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2246 for(idx=0; idx<elementCnt; idx++)
2248 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
2249 if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
2251 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2255 if(idx < elementCnt)
2258 /* Filling RIC Request Id */
2260 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
2261 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2262 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
2263 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
2264 if(BuildNewRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID, \
2265 &ricSubsInfo->requestId) != ROK)
2267 DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
2272 /* Filling RAN Function Id */
2274 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
2275 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2276 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
2277 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
2278 ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ranFuncDb->id;
2279 ricSubsInfo->ranFuncId = ranFuncDb->id;
2281 /* Filling RIC Subscription Details */
2283 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
2284 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2285 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
2286 RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
2287 if(BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails),\
2288 ricSubsInfo) != ROK)
2290 DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
2294 /* Prints the Msg formed */
2295 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
2297 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2299 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
2300 if(encRetVal.encoded == ENCODE_FAIL)
2302 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
2303 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2308 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
2309 for(int i=0; i< encBufSize; i++)
2311 DU_LOG("%x",encBuf[i]);
2316 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
2318 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
2322 /* Add RIC Subscription Info to RAN Function's RIC Subscription List */
2323 RIC_ALLOC(ricSubsNode , sizeof(CmLList));
2326 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2329 ricSubsNode->node = (PTR)ricSubsInfo;
2330 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubsNode);
2338 RIC_FREE(ricSubsInfo, sizeof(RicSubscription));
2339 RIC_FREE(ricSubsNode , sizeof(CmLList));
2342 FreeRicSubscriptionReq(e2apRicMsg);
2346 /*******************************************************************
2348 * @brief Process RicSubscriptionResponse
2352 * Function : ProcRicSubscriptionRsp
2354 * Functionality: Processes RicSubscriptionRsp
2356 * @return ROK - void
2358 ******************************************************************/
2360 void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp)
2362 uint8_t duIdx = 0, ieIdx = 0, notAdmitIdx = 0;
2363 uint8_t ranFuncId = 0, actionId = 0;
2365 bool ricReqIdDecoded = false;
2366 RicRequestId ricReqId;
2367 RanFunction *ranFuncDb = NULLP;
2368 RicSubscription *ricSubs = NULLP;
2369 CmLList *ricSubsNode = NULLP;
2370 CmLList *actionNode = NULLP;
2371 ActionInfo *action = NULLP;
2372 RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP;
2373 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
2375 DU_LOG("\nINFO --> E2AP : RIC Subscription Response received");
2378 SEARCH_DU_DB(duIdx, duId, duDb);
2381 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
2385 memset(&ricReqId, 0, sizeof(RicRequestId));
2386 if(ricSubscriptionRsp)
2388 if(ricSubscriptionRsp->protocolIEs.list.array)
2390 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
2392 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx])
2394 ricSubsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2395 switch(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]->id)
2397 case ProtocolIE_IDE2_id_RICrequestID:
2399 ricReqId.requestorId = ricSubsRspIe->value.choice.RICrequestID.ricRequestorID;
2400 ricReqId.instanceId = ricSubsRspIe->value.choice.RICrequestID.ricInstanceID;
2401 ricReqIdDecoded = true;
2404 case ProtocolIE_IDE2_id_RANfunctionID:
2406 ranFuncId = ricSubsRspIe->value.choice.RANfunctionID;
2407 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
2410 DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId);
2415 case ProtocolIE_IDE2_id_RICactions_Admitted:
2419 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
2421 if(!(ranFuncDb && ricReqIdDecoded))
2424 notAdmitList = &ricSubsRspIe->value.choice.RICaction_NotAdmitted_List;
2425 for(notAdmitIdx = 0; notAdmitIdx < notAdmitList->list.count; notAdmitIdx++)
2428 actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\
2429 value.choice.RICaction_NotAdmitted_Item.ricActionID;
2431 /* Remove action from RAN Function's subscription list */
2432 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
2435 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
2438 cmLListDelFrm(&ricSubs->actionSequence, actionNode);
2439 deleteActionSequence(actionNode);
2452 /*******************************************************************
2454 * @brief deallocate the memory allocated in E2SetupFailure
2458 * Function : FreeE2SetupFailure
2460 * Functionality: deallocate the memory allocated in E2SetupFailure
2462 * @params[in] E2AP_PDU_t *e2apMsg
2465 * ****************************************************************/
2466 void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg)
2469 E2setupFailure_t *e2SetupFail;
2473 if(e2apMsg->choice.unsuccessfulOutcome)
2475 e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
2476 if(e2SetupFail->protocolIEs.list.array)
2478 for(arrIdx=0; arrIdx<e2SetupFail->protocolIEs.list.count; arrIdx++)
2480 RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t));
2482 RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size);
2484 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
2486 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2490 /*******************************************************************
2492 * @brief Buld and send the E2 Setup failure
2496 * Function : BuildAndSendE2SetupFailure
2499 * - Buld and send the E2 Setup failure
2500 * @return ROK - success
2503 * ****************************************************************/
2505 uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint16_t transId)
2507 uint8_t ret = RFAILED;
2508 E2AP_PDU_t *e2apMsg = NULL;
2509 E2setupFailure_t *e2SetupFailure;
2510 asn_enc_rval_t encRetVal;
2513 bool memAllocFailed = false;
2515 DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
2518 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2519 if(e2apMsg == NULLP)
2521 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2524 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
2525 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
2526 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
2528 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2532 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
2533 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
2534 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure;
2535 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
2538 e2SetupFailure->protocolIEs.list.count = elementCnt;
2539 e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *);
2541 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
2542 if(e2SetupFailure->protocolIEs.list.array == NULLP)
2544 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2548 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2550 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
2551 if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
2553 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2554 memAllocFailed = true;
2559 if(memAllocFailed == true)
2561 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2567 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2568 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2569 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
2570 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2573 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
2574 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2575 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
2576 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol;
2577 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified;
2580 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
2581 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
2582 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
2583 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
2585 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2586 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2588 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2590 /* Check encode results */
2591 if(encRetVal.encoded == ENCODE_FAIL)
2593 DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
2594 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2599 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
2600 for(int i=0; i< encBufSize; i++)
2602 DU_LOG("%x",encBuf[i]);
2606 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2608 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
2616 FreeE2SetupFailure(e2apMsg);
2620 /*******************************************************************
2622 * @brief process the e2setup request
2626 * Function : ProcE2SetupReq
2628 * Functionality: process the e2setup request
2632 ******************************************************************/
2634 void ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
2636 uint8_t arrIdx = 0, duIdx = 0;
2637 uint16_t transId =0;
2638 uint16_t ranFuncIdx=0, e2NodeAddListIdx =0;
2639 E2NodeConfigList tmpE2NodeList;
2641 E2nodeComponentConfigAddition_List_t *e2NodeAddList=NULLP;
2642 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem=NULLP;
2643 RANfunction_ItemIEs_t *ranFuncItemIe=NULLP;
2644 RANfunction_Item_t *ranFunItem=NULLP;
2645 RANfunctions_List_t *ranFunctionsList=NULLP;
2647 memset(&tmpE2NodeList, 0, sizeof(E2NodeConfigList));
2650 DU_LOG("\nERROR --> E2AP : e2SetupReq pointer is null");
2653 if(!e2SetupReq->protocolIEs.list.array)
2655 DU_LOG("\nERROR --> E2AP : e2SetupReq array pointer is null");
2659 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
2661 if(e2SetupReq->protocolIEs.list.array[arrIdx])
2663 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
2665 case ProtocolIE_IDE2_id_TransactionID:
2667 transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2670 case ProtocolIE_IDE2_id_GlobalE2node_ID:
2672 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID)
2674 *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0];
2676 SEARCH_DU_DB(duIdx, *duId, duDb);
2679 duDb = &ricCb.duInfo[ricCb.numDu];
2682 memset(duDb, 0, sizeof(DuDb));
2687 case ProtocolIE_IDE2_id_RANfunctionsAdded:
2689 ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2691 if(ranFunctionsList->list.array)
2693 for(ranFuncIdx=0;ranFuncIdx<ranFunctionsList->list.count; ranFuncIdx++)
2695 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
2696 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2697 duDb->ranFunction[ranFunItem->ranFunctionID-1].id = ranFunItem->ranFunctionID;
2698 duDb->ranFunction[ranFunItem->ranFunctionID-1].revisionCounter = ranFunItem->ranFunctionRevision;
2699 cmLListInit(&duDb->ranFunction[ranFunItem->ranFunctionID-1].subscriptionList);
2700 duDb->numOfRanFunction++;
2705 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
2707 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
2708 if(e2NodeAddList->list.array)
2710 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
2712 if(e2NodeAddList->list.array[e2NodeAddListIdx])
2714 /* Storing the E2 node information in DB */
2715 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *)e2NodeAddList->list.array[e2NodeAddListIdx];
2716 if(handleE2NodeComponentAction(duDb, (PTR)&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item,\
2717 ProtocolIE_IDE2_id_E2nodeComponentConfigAddition, &tmpE2NodeList.addedE2Node[tmpE2NodeList.addedE2NodeCount++]) != ROK)
2719 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",e2NodeAddListIdx);
2733 if(BuildAndSendE2SetupRsp(duDb, transId, tmpE2NodeList) !=ROK)
2735 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
2738 /*******************************************************************
2740 * @brief Deallocate the memory allocated for E2 Reset Response
2744 * Function : FreeE2ResetResponse
2747 * - freeing the memory allocated for E2ResetResponse
2749 * @params[in] E2AP_PDU_t *e2apMsg
2750 * @return ROK - success
2753 * ****************************************************************/
2754 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
2757 ResetResponseE2_t *resetResponse =NULLP;
2759 if(e2apMsg != NULLP)
2761 if(e2apMsg->choice.successfulOutcome != NULLP)
2763 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
2764 if(resetResponse->protocolIEs.list.array)
2766 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
2768 if(resetResponse->protocolIEs.list.array[ieIdx])
2770 RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
2773 RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
2775 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2777 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2781 /*******************************************************************
2783 * @brief Buld and send the Reset Response msg
2787 * Function : BuildAndSendResetResponse
2790 * - Buld and send the Reset Response Message
2795 * @return ROK - success
2798 * ****************************************************************/
2799 uint8_t BuildAndSendResetResponse(uint32_t duId, uint16_t transId)
2801 uint8_t ieIdx = 0, elementCnt = 0;
2802 uint8_t ret = RFAILED;
2803 E2AP_PDU_t *e2apMsg = NULLP;
2804 ResetResponseE2_t *resetResponse=NULL;
2805 asn_enc_rval_t encRetVal; /* Encoder return value */
2807 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
2810 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2811 if(e2apMsg == NULLP)
2813 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
2816 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
2818 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2819 if(e2apMsg->choice.successfulOutcome == NULLP)
2821 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
2825 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
2826 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2827 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
2828 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
2831 resetResponse->protocolIEs.list.count = elementCnt;
2832 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
2833 RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
2834 if(!resetResponse->protocolIEs.list.array)
2836 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
2840 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
2842 RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
2843 if(!resetResponse->protocolIEs.list.array[ieIdx])
2845 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
2849 if(ieIdx < elementCnt)
2853 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2854 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
2855 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
2856 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
2858 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2860 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2862 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2863 if(encRetVal.encoded == ENCODE_FAIL)
2865 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
2866 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2871 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
2872 for(int i=0; i< encBufSize; i++)
2874 DU_LOG("%x",encBuf[i]);
2879 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2881 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
2889 FreeE2ResetResponse(e2apMsg);
2893 /*******************************************************************
2895 * @brief deallocate the memory allocated in building the
2896 * Service Query message
2900 * Function : FreeRicServiceQuery
2902 * Functionality: deallocate the memory allocated in building
2903 * Ric Service Query message
2905 * @params[in] E2AP_PDU_t *e2apMsg
2908 * ****************************************************************/
2910 void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg)
2912 uint8_t arrIdx = 0, ranFuncIdx=0;
2913 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
2914 RICserviceQuery_t *ricServiceQuery=NULL;
2918 if(e2apMsg->choice.initiatingMessage)
2920 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
2921 if(ricServiceQuery->protocolIEs.list.array)
2923 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
2925 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
2927 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
2929 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2931 ranFuncAcceptedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2932 if(ranFuncAcceptedList->list.array)
2934 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
2936 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
2938 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
2942 case RICserviceQuery_IEs__value_PR_TransactionID:
2947 RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
2950 RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
2952 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2954 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2958 /*******************************************************************
2960 * @brief build and send the ric service Query
2964 * Function : BuildAndSendRicServiceQuery
2966 * Functionality: build and send the ric service Query
2967 * @return ROK - success
2968 * RFAILED - Acknowledge
2970 ******************************************************************/
2972 uint8_t BuildAndSendRicServiceQuery(DuDb *duDb)
2976 uint8_t ret = RFAILED;
2977 bool memAllocFailed = false;
2978 E2AP_PDU_t *e2apMsg = NULL;
2979 asn_enc_rval_t encRetVal;
2980 RICserviceQuery_t *ricServiceQuery;
2982 DU_LOG("\nINFO --> E2AP : Building Ric service Query\n");
2985 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2986 if(e2apMsg == NULLP)
2988 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2991 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2992 RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2));
2993 if(e2apMsg->choice.initiatingMessage == NULLP)
2995 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2999 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery;
3000 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
3001 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery;
3002 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
3005 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
3006 if(duDb->numOfRanFunction)
3009 ricServiceQuery->protocolIEs.list.count = elementCnt;
3010 ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*);
3012 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
3013 if(ricServiceQuery->protocolIEs.list.array == NULLP)
3015 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
3019 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3021 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
3022 if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP)
3024 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
3025 memAllocFailed = true;
3029 if(memAllocFailed == true)
3031 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
3037 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3038 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3039 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID;
3040 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb);
3042 if(duDb->numOfRanFunction)
3044 /* Accepted RAN function Id */
3046 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
3047 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3048 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List;
3049 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK)
3051 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
3056 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3057 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3059 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3061 /* Check encode results */
3062 if(encRetVal.encoded == ENCODE_FAIL)
3064 DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
3065 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3070 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
3071 for(int i=0; i< encBufSize; i++)
3073 DU_LOG("%x",encBuf[i]);
3077 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
3079 DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed");
3086 FreeRicServiceQuery(e2apMsg);
3090 /*******************************************************************
3092 * @brief deallocate the memory allocated in RicServiceUpdateFailure
3096 * Function : FreeRicServiceUpdateFailure
3098 * Functionality: deallocate the memory allocated in RicServiceUpdatefailure
3100 * @params[in] E2AP_PDU_t *e2apMsg
3103 * ****************************************************************/
3105 void FreeRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
3108 RICserviceUpdateFailure_t *ricServiceUpdateFailure=NULL;
3112 if(e2apMsg->choice.unsuccessfulOutcome)
3114 ricServiceUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
3115 if(ricServiceUpdateFailure->protocolIEs.list.array)
3117 for(arrIdx=0; arrIdx<ricServiceUpdateFailure->protocolIEs.list.count; arrIdx++)
3119 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
3121 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array, ricServiceUpdateFailure->protocolIEs.list.size);
3123 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3125 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3129 /*******************************************************************
3131 * @brief build and send the ric service update failure
3135 * Function : BuildAndSendRicServiceUpdateFailure
3137 * Functionality: build and send the ric service update failure
3138 * @return ROK - success
3141 ******************************************************************/
3143 uint8_t BuildAndSendRicServiceUpdateFailure(uint32_t duId, uint16_t transId, CauseE2_PR causePresent, uint8_t reason)
3146 E2AP_PDU_t *e2apMsg = NULL;
3147 asn_enc_rval_t encRetVal;
3148 uint8_t ret = RFAILED;
3150 uint8_t elementCnt=0;
3151 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
3153 DU_LOG("\nINFO --> E2AP : Building Ric service update failure\n");
3156 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3157 if(e2apMsg == NULLP)
3159 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3162 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3163 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
3164 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3166 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3170 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
3171 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3172 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure;
3173 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
3176 ricServiceFailure->protocolIEs.list.count = elementCnt;
3177 ricServiceFailure->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateFailure_IEs_t *);
3179 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array, ricServiceFailure->protocolIEs.list.size);
3180 if(ricServiceFailure->protocolIEs.list.array == NULLP)
3182 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3186 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3188 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
3189 if(ricServiceFailure->protocolIEs.list.array[arrIdx] == NULLP)
3191 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3195 if(arrIdx<elementCnt)
3197 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3203 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3204 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3205 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TransactionID;
3206 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
3209 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
3210 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3211 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_CauseE2;
3212 fillE2FailureCause(&ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, causePresent, reason);
3215 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
3216 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
3217 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TimeToWaitE2;
3218 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
3220 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3221 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3223 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3225 /* Check encode results */
3226 if(encRetVal.encoded == ENCODE_FAIL)
3228 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\
3229 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3234 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n");
3235 for(int i=0; i< encBufSize; i++)
3237 DU_LOG("%x",encBuf[i]);
3241 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
3243 DU_LOG("\nERROR --> E2AP : Sending RIC service update failed");
3250 FreeRicServiceUpdateFailure(e2apMsg);
3255 /*******************************************************************
3257 * @brief deallocate the memory allocated in RicServiceUpdateAck(
3261 * Function : FreeRicServiceUpdateAck
3263 * Functionality: deallocate the memory allocated in RicServiceUpdateAck
3265 * @params[in] E2AP_PDU_t *e2apMsg
3268 * ****************************************************************/
3270 void FreeRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
3272 uint8_t arrIdx = 0, ranFuncIdx=0;
3273 RANfunctionsID_List_t *acceptedList=NULL;
3274 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
3275 RANfunctionsIDcause_List_t *rejectedList=NULL;
3279 if(e2apMsg->choice.successfulOutcome)
3281 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
3282 if(ricServiceUpdateAck->protocolIEs.list.array)
3284 for(arrIdx=0; arrIdx<ricServiceUpdateAck->protocolIEs.list.count; arrIdx++)
3286 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx])
3288 switch(ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id)
3290 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
3292 acceptedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3293 if(acceptedList->list.array)
3295 for(ranFuncIdx=0;ranFuncIdx<acceptedList->list.count; ranFuncIdx++)
3297 RIC_FREE(acceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
3299 RIC_FREE(acceptedList->list.array, acceptedList->list.size);
3304 case ProtocolIE_IDE2_id_RANfunctionsRejected:
3306 rejectedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
3307 if(rejectedList->list.array)
3309 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
3311 RIC_FREE(rejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
3313 RIC_FREE(rejectedList->list.array, rejectedList->list.size);
3318 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
3321 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
3323 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
3325 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3329 /*******************************************************************
3331 * @brief Build RAN function rejected list
3335 * Function : BuildRanFunctionRejectedList
3337 * Functionality: Build RAN function rejected list
3340 * Count of ran functions to be rejected in the list
3341 * Received list of RAN functions
3343 * @return ROK - success
3345 * ****************************************************************/
3347 uint8_t BuildRanFunctionRejectedList(uint8_t count, RanFunction *ranFunRejectedList, RANfunctionsIDcause_List_t *ranFuncRejectedList)
3349 uint8_t ranFuncIdx = 0;
3350 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
3352 ranFuncRejectedList->list.count = count;
3354 ranFuncRejectedList->list.size = ranFuncRejectedList->list.count*sizeof(RANfunctionIDcause_ItemIEs_t*);
3355 RIC_ALLOC(ranFuncRejectedList->list.array, ranFuncRejectedList->list.size);
3356 if(ranFuncRejectedList->list.array == NULLP)
3358 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array");
3362 for(ranFuncIdx = 0; ranFuncIdx< ranFuncRejectedList->list.count; ranFuncIdx++)
3364 RIC_ALLOC(ranFuncRejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
3365 if(ranFuncRejectedList->list.array[ranFuncIdx] == NULLP)
3367 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array item");
3370 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[ranFuncIdx];
3371 ranFuncRejectedItemIe->id = ProtocolIE_IDE2_id_RANfunctionIEcause_Item;
3372 ranFuncRejectedItemIe->criticality= CriticalityE2_ignore;
3373 ranFuncRejectedItemIe->value.present = RANfunctionIDcause_ItemIEs__value_PR_RANfunctionIDcause_Item;
3374 ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID = ranFunRejectedList[ranFuncIdx].id;
3375 fillE2FailureCause(&ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.cause, CauseE2_PR_ricService,\
3376 CauseE2RICservice_ran_function_not_supported);
3382 /*******************************************************************
3384 * @brief build and send the ric service update Acknowledge
3388 * Function : BuildAndSendRicServiceUpdateAcknowledge
3390 * Functionality: build and send the ric service update Acknowledge
3391 * @return ROK - success
3392 * RFAILED - Acknowledge
3394 ******************************************************************/
3396 uint8_t BuildAndSendRicServiceUpdateAcknowledge(DuDb *duDb, uint16_t transId, RicTmpRanFunList ricRanFuncList)
3398 E2AP_PDU_t *e2apMsg = NULL;
3399 asn_enc_rval_t encRetVal;
3400 uint8_t arrIdx=0, elementCnt=0, ret=RFAILED;;
3401 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
3403 DU_LOG("\nINFO --> E2AP : Building Ric service update Acknowledge\n");
3406 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3407 if(e2apMsg == NULLP)
3409 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3412 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
3413 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(struct SuccessfulOutcomeE2));
3414 if(e2apMsg->choice.successfulOutcome == NULLP)
3416 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3420 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
3421 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
3422 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge;
3423 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
3426 if(ricRanFuncList.numOfRanFunAccepted)
3428 if(ricRanFuncList.numOfRanFuneRejected)
3432 ricServiceUpdateAck->protocolIEs.list.count = elementCnt;
3433 ricServiceUpdateAck->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateAcknowledge_IEs_t*);
3435 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
3436 if(ricServiceUpdateAck->protocolIEs.list.array == NULLP)
3438 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3442 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3444 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
3445 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
3447 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3451 if(arrIdx<elementCnt)
3453 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3459 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3460 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3461 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_TransactionID;
3462 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
3464 if(ricRanFuncList.numOfRanFunAccepted)
3466 /* Accepted RAN function List */
3468 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
3469 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3470 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsID_List;
3471 if(BuildRanFunctionAcceptedList(duDb, ricRanFuncList.numOfRanFunAccepted, ricRanFuncList.ranFunAcceptedList,\
3472 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceUpdate)!=ROK)
3474 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
3479 if(ricRanFuncList.numOfRanFuneRejected)
3481 /* RAN Functions Rejected List */
3483 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsRejected;
3484 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3485 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsIDcause_List;
3486 if(BuildRanFunctionRejectedList(ricRanFuncList.numOfRanFuneRejected, ricRanFuncList.ranFunRejectedList, \
3487 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List)!=ROK)
3489 DU_LOG("\nERROR --> E2AP : Failed to build Ran function rejected list");
3495 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3496 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3498 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3500 /* Check encode results */
3501 if(encRetVal.encoded == ENCODE_FAIL)
3503 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\
3504 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3509 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\n");
3510 for(int i=0; i< encBufSize; i++)
3512 DU_LOG("%x",encBuf[i]);
3516 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
3518 DU_LOG("\nERROR --> E2AP : Sending RIC service update ack failed");
3524 FreeRicServiceUpdateAck(e2apMsg);
3528 /*******************************************************************
3530 * @brief process the RIC service update
3534 * Function : ProcRicserviceUpdate
3536 * Functionality: process the RIC service update
3538 * @return ROK - success
3541 ******************************************************************/
3543 void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate)
3545 RicTmpRanFunList ricRanFuncList;
3548 uint8_t duIdx = 0, elementCnt =0, arrIdx = 0;
3549 uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0;
3550 RanFunction *ranFuncDb = NULLP;
3551 RANfunction_ItemIEs_t *ranFuncItemIe =NULL;
3552 RANfunction_Item_t *ranFuncItem =NULL;
3553 RANfunctionID_Item_t *ranFuncIdItem=NULL;
3554 RANfunctions_List_t *ranFuncList=NULL;
3555 RANfunctionsID_List_t *deleteList=NULL;
3556 RANfunctionID_ItemIEs_t *delRanFuncItem=NULL;
3558 SEARCH_DU_DB(duIdx, duId, duDb);
3561 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
3564 memset(&ricRanFuncList, 0, sizeof(RicTmpRanFunList));
3566 if(!ricServiceUpdate)
3568 DU_LOG("\nERROR --> E2AP : ricServiceUpdate pointer is null");
3572 if(!ricServiceUpdate->protocolIEs.list.array)
3574 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array pointer is null");
3577 elementCnt = ricServiceUpdate->protocolIEs.list.count;
3578 for(arrIdx=0; arrIdx<ricServiceUpdate->protocolIEs.list.count; arrIdx++)
3580 if(!ricServiceUpdate->protocolIEs.list.array[arrIdx])
3582 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx);
3586 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
3588 case ProtocolIE_IDE2_id_TransactionID:
3590 transId = ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
3592 if(transId < 0 || transId > 255)
3594 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
3600 case ProtocolIE_IDE2_id_RANfunctionsAdded:
3602 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
3604 if(ranFuncList->list.array)
3606 for(ranFuncIdx=0;ranFuncIdx<ranFuncList->list.count; ranFuncIdx++)
3608 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
3609 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
3611 /* Adding the ran function in temporary list */
3612 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
3613 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
3614 ricRanFuncList.numOfRanFunAccepted++;
3616 /* Adding the new ran function in DB*/
3617 duDb->ranFunction[ranFuncItem->ranFunctionID-1].id = ranFuncItem->ranFunctionID;
3618 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
3619 duDb->numOfRanFunction++;
3621 /* Calculating total number of ran fuctions which are received for addition */
3622 recvdRanFuncCount++;
3628 case ProtocolIE_IDE2_id_RANfunctionsModified:
3631 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
3632 if(ranFuncList->list.array)
3634 for(ranFuncIdx = 0; ranFuncIdx< ranFuncList->list.count; ranFuncIdx++)
3636 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
3637 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
3638 if(fetchRanFuncFromRanFuncId(duDb, ranFuncItem->ranFunctionID) == NULLP)
3640 /* Calculating total number of ran fuctions which are not present */
3641 failedRanFuncCount++;
3643 /* Adding the ran function in temporary list */
3644 ricRanFuncList.ranFunRejectedList[ricRanFuncList.numOfRanFuneRejected].id = ranFuncItem->ranFunctionID;
3645 ricRanFuncList.numOfRanFuneRejected++;
3650 /* Adding the ran function in temporary list */
3651 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
3652 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
3653 ricRanFuncList.numOfRanFunAccepted++;
3655 /* Updating the new ran function in DB*/
3656 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
3658 /* Calculating total number of ran fuctions which are received for modification */
3659 recvdRanFuncCount++;
3664 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
3667 deleteList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3668 if(deleteList->list.array)
3670 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
3672 delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx];
3673 ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item;
3674 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncIdItem->ranFunctionID);
3677 memset(ranFuncDb, 0, sizeof(RanFunction));
3678 duDb->numOfRanFunction--;
3681 /* Calculating total number of ran fuctions which are received for deletion */
3682 recvdRanFuncCount++;
3690 DU_LOG("\nERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id);
3696 /* Sending RIC Service Update Failed if all RAN Functions received fail or if any IE processing fails
3697 * Else sending RIC Service Update Acknowledge */
3698 if((elementCnt > arrIdx) ||((recvdRanFuncCount > 0) && (recvdRanFuncCount == failedRanFuncCount)))
3700 if(BuildAndSendRicServiceUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
3702 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update Failure");
3708 if(BuildAndSendRicServiceUpdateAcknowledge(duDb, transId, ricRanFuncList) != ROK)
3710 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update acknowledge");
3716 /*******************************************************************
3718 * @brief Processing RIC subscription failure from DU
3722 * Function : ProcRicSubscriptionFailure
3724 * Functionality: Processing RIC subscription failure from DU
3726 * @param ID of DU from which message was sent
3727 * RIC Subscription failure message
3728 * @return ROK - success
3731 ******************************************************************/
3732 uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricSubscriptionFailure)
3734 uint8_t ieIdx = 0, duIdx = 0;
3735 uint8_t ranFuncId = 0;
3737 RanFunction *ranFuncDb = NULLP;
3738 RicSubscription *ricSubs = NULLP;
3739 CmLList *ricSubsNode = NULLP;
3740 RicRequestId ricReqId;
3741 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3743 DU_LOG("\nINFO --> E2AP : Received RIC subscription failure");
3745 SEARCH_DU_DB(duIdx, duId, duDb);
3748 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
3752 memset(&ricReqId, 0, sizeof(RicRequestId));
3753 if(ricSubscriptionFailure)
3755 if(ricSubscriptionFailure->protocolIEs.list.array)
3757 for(ieIdx=0; ieIdx<ricSubscriptionFailure->protocolIEs.list.count; ieIdx++)
3759 if(ricSubscriptionFailure->protocolIEs.list.array[ieIdx])
3761 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[ieIdx];
3762 switch(ricSubscriptionFailure->protocolIEs.list.array[ieIdx]->id)
3764 case ProtocolIE_IDE2_id_RICrequestID:
3766 ricReqId.requestorId = ricSubsFailIe->value.choice.RICrequestID.ricRequestorID;
3767 ricReqId.instanceId = ricSubsFailIe->value.choice.RICrequestID.ricInstanceID;
3770 case ProtocolIE_IDE2_id_RANfunctionID:
3772 ranFuncId = ricSubsFailIe->value.choice.RANfunctionID;
3773 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
3776 DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId);
3781 /* Remove subscription entry from RAN Function */
3782 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
3785 cmLListDelFrm(&ranFuncDb->subscriptionList, ricSubsNode);
3786 deleteRicSubscriptionNode(ricSubsNode);
3791 case ProtocolIE_IDE2_id_CauseE2:
3793 /* No handling required as of now since this is a stub */
3803 /*******************************************************************
3805 * @brief Free RIC Subscription Modification Refuse
3809 * Function : FreeRicSubsModRefuse
3811 * Functionality: Free RIC Subscription Modification Refuse
3813 * @param E2AP Message PDU to be freed
3816 ******************************************************************/
3817 void FreeRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
3820 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
3824 if(e2apMsg->choice.unsuccessfulOutcome)
3826 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
3827 if(ricSubsModRefuse->protocolIEs.list.array)
3829 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
3831 RIC_FREE(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
3833 RIC_FREE(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
3835 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
3837 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3841 /*******************************************************************
3843 * @brief Build And Send RIC Subscription Modification Refuse
3847 * Function : BuildAndSendRicSubsModRefuse
3849 * Functionality: Build And Send RIC Subscription Modification Refuse
3852 * RIC Request ID of subscription
3856 * @return ROK - success
3859 ******************************************************************/
3860 uint8_t BuildAndSendRicSubsModRefuse(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, CauseE2_PR causeType, \
3863 uint8_t ieIdx = 0, elementCnt = 0;
3864 uint8_t ret = RFAILED;
3865 E2AP_PDU_t *e2apMsg = NULL;
3866 asn_enc_rval_t encRetVal;
3867 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
3868 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
3870 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Refuse\n");
3873 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3874 if(e2apMsg == NULLP)
3876 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3879 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3880 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
3881 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3883 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3887 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
3888 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3889 e2apMsg->choice.unsuccessfulOutcome->value.present = \
3890 UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse;
3891 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
3894 ricSubsModRefuse->protocolIEs.list.count = elementCnt;
3895 ricSubsModRefuse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRefuse_IEs_t *);
3896 RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
3897 if(!ricSubsModRefuse->protocolIEs.list.array)
3899 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3903 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
3905 RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
3906 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
3908 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3913 /* RIC Request ID */
3915 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3916 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RICrequestID;
3917 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3918 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RICrequestID;
3919 ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3920 ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3922 /* RAN Function ID */
3924 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3925 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3926 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3927 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RANfunctionID;
3928 ricSubsModRefuseIe->value.choice.RANfunctionID = ranFuncId;
3932 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3933 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_CauseE2;
3934 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3935 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_CauseE2;
3936 fillE2FailureCause(&ricSubsModRefuseIe->value.choice.CauseE2, causeType, cause);
3938 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3939 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3941 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3943 /* Check encode results */
3944 if(encRetVal.encoded == ENCODE_FAIL)
3946 DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification refuse (at %s)\n",\
3947 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3952 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification refuse\n");
3953 for(int i=0; i< encBufSize; i++)
3955 DU_LOG("%x",encBuf[i]);
3959 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
3961 DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Refused");
3968 FreeRicSubsModRefuse(e2apMsg);
3972 /*******************************************************************
3974 * @brief Free memory for RIC Subscription Modification Confirm
3978 * Function : FreeRicSubsModConfirm
3980 * Functionality: Free memory for RIC subscription modification
3983 * @param E2AP Message PDU to be freed
3986 ******************************************************************/
3987 void FreeRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
3989 uint8_t ieIdx = 0, arrIdx=0;
3990 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
3991 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
3992 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
3993 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
3994 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
3995 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
3999 if(e2apMsg->choice.successfulOutcome)
4001 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
4002 if(ricSubsModCfm->protocolIEs.list.array)
4004 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
4006 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
4008 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4009 switch(ricSubsModCfmIe->id)
4011 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
4013 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
4014 if(modCfmList->list.array)
4016 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
4018 RIC_FREE(modCfmList->list.array[arrIdx], \
4019 sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
4021 RIC_FREE(modCfmList->list.array, modCfmList->list.size);
4026 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
4028 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
4029 if(modRefusedList->list.array)
4031 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
4033 RIC_FREE(modRefusedList->list.array[arrIdx], \
4034 sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
4036 RIC_FREE(modRefusedList->list.array, modRefusedList->list.size);
4041 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
4043 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
4044 if(rmvCfmList->list.array)
4046 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
4048 RIC_FREE(rmvCfmList->list.array[arrIdx], \
4049 sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
4051 RIC_FREE(rmvCfmList->list.array, rmvCfmList->list.size);
4056 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
4058 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
4059 if(rmvFailList->list.array)
4061 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
4063 RIC_ALLOC(rmvFailList->list.array[arrIdx], \
4064 sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
4066 RIC_FREE(rmvFailList->list.array, rmvFailList->list.size);
4075 RIC_FREE(ricSubsModCfmIe, sizeof(RICsubscriptionModificationConfirm_IEs_t));
4078 RIC_FREE(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
4080 RIC_FREE(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
4082 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4086 /*******************************************************************
4088 * @brief Fill the list of actions confirmed for modification
4092 * Function : fillActionModConfirmedList
4094 * Functionality: Fill the list of actions confirmed for modification
4096 * @param List to be filled
4098 * Source list of actions
4099 * @return ROK - success
4102 ******************************************************************/
4103 uint8_t fillActionModConfirmedList(RICactions_ConfirmedForModification_List_t *modCfmList, uint8_t numActions, \
4104 uint8_t *actionModifiedList)
4107 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
4109 modCfmList->list.count = numActions;
4110 modCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForModification_ItemIEs_t *);
4111 RIC_ALLOC(modCfmList->list.array, modCfmList->list.size);
4112 if(!modCfmList->list.array)
4114 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4118 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
4120 RIC_ALLOC(modCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
4121 if(!modCfmList->list.array[arrIdx])
4123 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4127 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
4128 modCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForModification_Item;
4129 modCfmListItem->criticality = CriticalityE2_ignore;
4130 modCfmListItem->value.present = \
4131 RICaction_ConfirmedForModification_ItemIEs__value_PR_RICaction_ConfirmedForModification_Item;
4132 modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID = actionModifiedList[arrIdx];
4138 /*******************************************************************
4140 * @brief Fill the list of actions refused to be modified
4144 * Function : fillActionModRefusedList
4146 * Functionality: Fill the list of actions refused to be modified
4148 * @param List to be filled
4150 * Source list of actions refused tobe modified
4151 * @return ROK - success
4154 ******************************************************************/
4155 uint8_t fillActionModRefusedList(RICactions_RefusedToBeModified_List_t *modRefusedList, uint8_t numActions, \
4156 ActionFailed *actionModFailedList)
4159 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
4161 modRefusedList->list.count = numActions;
4162 modRefusedList->list.size = numActions * sizeof(RICaction_RefusedToBeModified_ItemIEs_t *);
4163 RIC_ALLOC(modRefusedList->list.array, modRefusedList->list.size);
4164 if(!modRefusedList->list.array)
4166 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4170 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
4172 RIC_ALLOC(modRefusedList->list.array[arrIdx], sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
4173 if(!modRefusedList->list.array[arrIdx])
4175 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4179 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
4180 modRefusedListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeModified_Item;
4181 modRefusedListItem->criticality = CriticalityE2_ignore;
4182 modRefusedListItem->value.present = \
4183 RICaction_RefusedToBeModified_ItemIEs__value_PR_RICaction_RefusedToBeModified_Item;
4184 modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID = \
4185 actionModFailedList[arrIdx].actionId;
4186 fillE2FailureCause(&modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.cause, \
4187 actionModFailedList[arrIdx].failureType, actionModFailedList[arrIdx].cause);
4193 /*******************************************************************
4195 * @brief Fill the list of action confirmed for removal
4199 * Function : fillActionRemovalConfirmedList
4201 * Functionality: Fill the list of action confirmed for removal
4203 * @param List to be filled
4205 * Source list of actions removed
4206 * @return ROK - success
4209 ******************************************************************/
4210 uint8_t fillActionRemovalConfirmedList(RICactions_ConfirmedForRemoval_List_t *rmvCfmList, uint8_t numActions, \
4211 uint8_t *actionRemovedList)
4214 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
4216 rmvCfmList->list.count = numActions;
4217 rmvCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t *);
4218 RIC_ALLOC(rmvCfmList->list.array, rmvCfmList->list.size);
4219 if(!rmvCfmList->list.array)
4221 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4225 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
4227 RIC_ALLOC(rmvCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
4228 if(!rmvCfmList->list.array[arrIdx])
4230 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4234 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
4235 rmvCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForRemoval_Item;
4236 rmvCfmListItem->criticality = CriticalityE2_ignore;
4237 rmvCfmListItem->value.present = \
4238 RICaction_ConfirmedForRemoval_ItemIEs__value_PR_RICaction_ConfirmedForRemoval_Item;
4239 rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID = actionRemovedList[arrIdx];
4245 /*******************************************************************
4247 * @brief Fill the list of actions refused to be removed
4251 * Function : fillActionRemovalRefusedList
4253 * Functionality: Fill the list of actions refused to be removed
4255 * @param List to be filled
4257 * Source list of actions refused to be removed
4258 * @return ROK - success
4261 ******************************************************************/
4262 uint8_t fillActionRemovalRefusedList(RICactions_RefusedToBeRemoved_List_t *rmvFailList, \
4263 uint8_t numActions, ActionFailed *actionRmvlFailList)
4266 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
4268 rmvFailList->list.count = numActions;
4269 rmvFailList->list.size = numActions * sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t *);
4270 RIC_ALLOC(rmvFailList->list.array, rmvFailList->list.size);
4271 if(!rmvFailList->list.array)
4273 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4277 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
4279 RIC_ALLOC(rmvFailList->list.array[arrIdx], sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
4280 if(!rmvFailList->list.array[arrIdx])
4282 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4286 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
4287 rmvFailListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeRemoved_Item;
4288 rmvFailListItem->criticality = CriticalityE2_ignore;
4289 rmvFailListItem->value.present = \
4290 RICaction_RefusedToBeRemoved_ItemIEs__value_PR_RICaction_RefusedToBeRemoved_Item;
4291 rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID = actionRmvlFailList[arrIdx].actionId;
4292 fillE2FailureCause(&rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.cause, \
4293 actionRmvlFailList[arrIdx].failureType, actionRmvlFailList[arrIdx].cause);
4300 /*******************************************************************
4302 * @brief Build And Send RIC Subscription Modification Confirm
4306 * Function : BuildAndSendRicSubsModConfirm
4308 * Functionality: Build And Send RIC Subscription Modification Confirm
4311 * RIC Request ID of subscription
4313 * Temporary source action list
4314 * @return ROK - success
4317 ******************************************************************/
4318 uint8_t BuildAndSendRicSubsModConfirm(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, RicTmpActionList tmpActionList)
4320 uint8_t ieIdx = 0, elementCnt = 0;
4321 uint8_t ret = RFAILED;
4322 E2AP_PDU_t *e2apMsg = NULLP;
4323 asn_enc_rval_t encRetVal;
4324 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
4325 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
4327 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Confirm\n");
4330 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4331 if(e2apMsg == NULLP)
4333 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4337 /* Successful Outcome */
4338 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
4339 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
4340 if(e2apMsg->choice.successfulOutcome == NULLP)
4342 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4346 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
4347 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
4348 e2apMsg->choice.successfulOutcome->value.present = \
4349 SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm;
4350 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
4353 if(tmpActionList.numActionModified)
4355 if(tmpActionList.numActionModFailed)
4357 if(tmpActionList.numActionRemoved)
4359 if(tmpActionList.numActionRemovalFailed)
4362 ricSubsModCfm->protocolIEs.list.count = elementCnt;
4363 ricSubsModCfm->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationConfirm_IEs_t *);
4364 RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
4365 if(!ricSubsModCfm->protocolIEs.list.array)
4367 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4371 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
4373 RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationConfirm_IEs_t));
4374 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
4376 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4381 /* RIC Request ID */
4383 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4384 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICrequestID;
4385 ricSubsModCfmIe->criticality = CriticalityE2_reject;
4386 ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RICrequestID;
4387 ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
4388 ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
4390 /* RAN Function ID */
4392 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4393 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RANfunctionID;
4394 ricSubsModCfmIe->criticality = CriticalityE2_reject;
4395 ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RANfunctionID;
4396 ricSubsModCfmIe->value.choice.RANfunctionID = ranFuncId;
4398 /* RIC Actions List confirmed for modification */
4399 if(tmpActionList.numActionModified)
4402 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4403 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List;
4404 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4405 ricSubsModCfmIe->value.present = \
4406 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForModification_List;
4407 if(fillActionModConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List, \
4408 tmpActionList.numActionModified, tmpActionList.actionModifiedList) != ROK)
4410 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Modification List", __func__);
4415 /* RIC Actions List refured to be modified */
4416 if(tmpActionList.numActionModFailed)
4419 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4420 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List;
4421 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4422 ricSubsModCfmIe->value.present = \
4423 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeModified_List;
4424 if(fillActionModRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List, \
4425 tmpActionList.numActionModFailed, tmpActionList.actionModFailedList) != ROK)
4427 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Refused to be Modified List", __func__);
4432 /* RIC Actions List confirmed for removal */
4433 if(tmpActionList.numActionRemoved)
4436 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4437 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List;
4438 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4439 ricSubsModCfmIe->value.present = \
4440 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForRemoval_List;
4441 if(fillActionRemovalConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List, \
4442 tmpActionList.numActionRemoved, tmpActionList.actionRemovedList) != ROK)
4444 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Removal List", __func__);
4449 /* RIC Actions List Refused to be removed */
4450 if(tmpActionList.numActionRemovalFailed)
4453 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4454 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List;
4455 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4456 ricSubsModCfmIe->value.present = \
4457 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeRemoved_List;
4458 if(fillActionRemovalRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List, \
4459 tmpActionList.numActionRemovalFailed, tmpActionList.actionRemovalFailedList) != ROK)
4461 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Failed to be Removed List", __func__);
4466 /* Print and encode E2AP Message PDU */
4467 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4468 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4470 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
4472 /* Check encode results */
4473 if(encRetVal.encoded == ENCODE_FAIL)
4475 DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification confirm (at %s)\n",\
4476 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4481 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification confirm\n");
4482 for(int i=0; i< encBufSize; i++)
4484 DU_LOG("%x",encBuf[i]);
4488 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
4490 DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Confirm");
4498 FreeRicSubsModConfirm(e2apMsg);
4502 /*******************************************************************
4504 * @brief Processing of RIC Subscription Modification Required
4508 * Function : ProcRicSubsModReqd
4510 * Functionality: Processing of RIC Subscription Modification Required
4511 * As of now, we do not identify any scenario where this message
4512 * shall be sent by DU. Hence, bare minimum handling has been
4516 * RIC Subscription Modification Required IEs
4517 * @return ROK-success
4520 ******************************************************************/
4521 uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t *ricSubsModReqd)
4523 uint8_t ieIdx = 0, actionIdx = 0, duIdx = 0;
4527 RicRequestId ricReqId;
4528 RanFunction *ranFuncDb = NULLP;
4529 RicSubscription *ricSubs = NULLP;
4530 CmLList *ricSubsNode = NULLP;
4531 CmLList *actionNode = NULLP;
4532 ActionInfo *action = NULLP;
4533 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
4534 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
4535 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
4536 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULLP;
4537 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULLP;
4538 RicTmpActionList tmpActionList;
4540 memset(&ricReqId, 0, sizeof(RicRequestId));
4541 memset(&tmpActionList, 0, sizeof(RicTmpActionList));
4543 SEARCH_DU_DB(duIdx, duId, duDb);
4546 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
4550 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
4552 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
4553 switch(ricSubsModReqdIe->id)
4555 case ProtocolIE_IDE2_id_RICrequestID:
4557 ricReqId.requestorId = ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID;
4558 ricReqId.instanceId = ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID;
4561 case ProtocolIE_IDE2_id_RANfunctionID:
4563 ranFuncId = ricSubsModReqdIe->value.choice.RANfunctionID;
4564 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
4567 /* If RIC Subscription not found, send RIC Subscription modification refuse to DU */
4568 DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RIC Subscription not found");
4569 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
4570 CauseE2RICrequest_ran_function_id_invalid);
4574 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
4577 /* If RAN Function not found, send RIC Subscription modification refuse to DU */
4578 DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RAN Function ID [%d] not found",ranFuncId);
4579 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, \
4580 CauseE2_PR_ricRequest, CauseE2RICrequest_request_id_unknown);
4585 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
4587 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
4588 for(actionIdx = 0; actionIdx < actionToBeModList->list.count; actionIdx++)
4591 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[actionIdx];
4592 actionId = actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID;
4593 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
4596 /* No modification required as of now, hence directly adding to the list */
4597 tmpActionList.actionModifiedList[tmpActionList.numActionModified++] = actionId;
4601 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].actionId = actionId;
4602 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].failureType = \
4603 CauseE2_PR_ricRequest;
4604 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].cause = \
4605 CauseE2RICrequest_action_not_supported;
4606 tmpActionList.numActionModFailed++;
4611 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
4613 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
4614 for(actionIdx = 0; actionIdx < actionToBeRmvList->list.count; actionIdx++)
4617 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[actionIdx];
4618 actionId = actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID;
4619 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
4622 tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId;
4623 cmLListDelFrm(&ricSubs->actionSequence, actionNode);
4624 deleteActionSequence(actionNode);
4634 /* If none of the action modification/removal is supported,
4635 * send RIC Subscription Modification Refuse
4637 * send RIC Subscription Modification Confirm
4639 if(tmpActionList.numActionModified || tmpActionList.numActionRemoved)
4641 BuildAndSendRicSubsModConfirm(duId, ricReqId, ranFuncId, tmpActionList);
4645 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
4646 CauseE2RICrequest_action_not_supported);
4652 /*******************************************************************
4654 * @brief Free the ErrorIndication Message
4658 * Function : FreeRicIndication
4660 * Functionality: Free the ErrorIndication Message
4665 ******************************************************************/
4666 void FreeErrorIndication(E2AP_PDU_t *e2apMsg)
4669 ErrorIndicationE2_t *errorIndicationMsg= NULLP;
4671 if(e2apMsg != NULLP)
4673 if(e2apMsg->choice.initiatingMessage != NULLP)
4675 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
4676 if(errorIndicationMsg!= NULLP)
4678 if(errorIndicationMsg->protocolIEs.list.array != NULLP)
4680 for(arrIdx=0; arrIdx<errorIndicationMsg->protocolIEs.list.count; arrIdx++)
4682 RIC_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t));
4684 RIC_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size);
4687 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4689 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4694 /*******************************************************************
4696 * @brief Builds and Send the ErrorIndication Message
4700 * Function : BuildAndSendErrorIndication
4702 * Functionality:Fills the ErrorIndication Message
4710 * @return ROK - success
4713 ******************************************************************/
4715 uint8_t BuildAndSendErrorIndication(uint32_t duId, uint16_t transId, RicRequestId requestId, uint16_t ranFuncId, uint8_t reason)
4717 uint8_t elementCnt =0, arrIdx=0, ret = RFAILED;
4718 E2AP_PDU_t *e2apMsg = NULLP;
4719 ErrorIndicationE2_t *errorIndicationMsg=NULLP;
4720 asn_enc_rval_t encRetVal; /* Encoder return value */
4724 DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
4726 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4727 if(e2apMsg == NULLP)
4729 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
4733 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4734 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4735 if(e2apMsg->choice.initiatingMessage == NULLP)
4737 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
4740 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
4741 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4742 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2;
4744 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
4746 /* Element count is 2 for TransactionID/RICrequestID and Cause.
4747 * If the RAN function id is present, the count will be increased.*/
4752 errorIndicationMsg->protocolIEs.list.count = elementCnt;
4753 errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*);
4755 /* Initialize the E2Setup members */
4756 RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
4757 if(errorIndicationMsg->protocolIEs.list.array == NULLP)
4759 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
4762 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
4764 RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
4765 if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
4767 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array Idx %d in %s at line %d",arrIdx,__func__, __LINE__);
4771 if(arrIdx < elementCnt)
4776 if(transId >=0 && transId<=255)
4779 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4780 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4781 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID;
4782 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4787 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID;
4788 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4789 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID;
4790 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId;
4791 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
4796 /* RAN Function ID */
4798 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID;
4799 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4800 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID;
4801 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId;
4806 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
4807 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
4808 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
4809 fillE2FailureCause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, CauseE2_PR_misc, reason);
4812 /* Prints the Msg formed */
4813 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4814 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4816 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4818 if(encRetVal.encoded == ENCODE_FAIL)
4820 DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
4821 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4826 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
4827 #ifdef DEBUG_ASN_PRINT
4828 for(int i=0; i< encBufSize; i++)
4830 printf("%x",encBuf[i]);
4835 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
4837 DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
4843 FreeErrorIndication(e2apMsg);
4847 /*******************************************************************
4849 * @brief Deallocate the memory allocated for ResetRequest msg
4853 * Function : FreeResetRequest
4856 * - freeing the memory allocated for ResetRequest
4858 * @params[in] E2AP_PDU_t *e2apMsg
4859 * @return ROK - success
4862 * ****************************************************************/
4863 void FreeResetRequest(E2AP_PDU_t *e2apMsg)
4866 ResetRequestE2_t *resetReq = NULLP;
4868 if(e2apMsg != NULLP)
4870 if(e2apMsg->choice.initiatingMessage != NULLP)
4872 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4873 if(resetReq->protocolIEs.list.array)
4875 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
4877 RIC_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4879 RIC_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4881 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4883 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4887 /*******************************************************************
4889 * @brief Build and send the reset request msg
4893 * Function : BuildAndSendResetRequest
4896 * - Buld and send the reset request msg to E2 node
4902 * @return ROK - success
4905 * ****************************************************************/
4906 uint8_t BuildAndSendResetRequest(DuDb *duDb, CauseE2_PR causePresent, uint8_t reason)
4908 uint8_t ieIdx = 0, elementCnt = 0;
4909 uint16_t transId = 0;
4910 uint8_t ret = RFAILED;
4911 E2AP_PDU_t *e2apMsg = NULLP;
4912 ResetRequestE2_t *resetReq = NULLP;
4913 asn_enc_rval_t encRetVal; /* Encoder return value */
4915 DU_LOG("\nINFO --> E2AP : Building Reset Request\n");
4919 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4920 if(e2apMsg == NULLP)
4922 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for E2AP-PDU failed");
4926 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4927 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4928 if(e2apMsg->choice.initiatingMessage == NULLP)
4930 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for initiatingMessage");
4934 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
4935 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4936 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
4937 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4940 resetReq->protocolIEs.list.count = elementCnt;
4941 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
4943 RIC_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4944 if(!resetReq->protocolIEs.list.array)
4946 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
4947 Reset Request IE array");
4951 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
4953 RIC_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4954 if(!resetReq->protocolIEs.list.array[ieIdx])
4956 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
4957 Reset Request IE array element");
4962 /* In case of failure */
4963 if(ieIdx < elementCnt)
4967 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4968 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
4969 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
4970 transId = assignTransactionId(duDb);
4971 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
4974 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
4975 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
4976 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
4977 fillE2FailureCause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
4979 /* Prints the Msg formed */
4980 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4982 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4984 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4986 if(encRetVal.encoded == ENCODE_FAIL)
4988 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
4989 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4994 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
4995 #ifdef DEBUG_ASN_PRINT
4996 for(int i=0; i< encBufSize; i++)
4998 printf("%x",encBuf[i]);
5002 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
5004 DU_LOG("\nERROR --> E2AP : Sending reset request failed");
5013 /* Free all memory */
5014 FreeResetRequest(e2apMsg);
5018 /******************************************************************
5020 * @brief Delete Ric subscription action
5024 * Function : deleteActionSequence
5026 * Functionality: Delete Ric subscription action
5028 * @params[in] Action info
5032 * ****************************************************************/
5033 void deleteActionSequence(CmLList *actionNode)
5035 ActionInfo *action = NULLP;
5039 action = (ActionInfo*)actionNode->node;
5040 memset(action, 0, sizeof(ActionInfo));
5041 RIC_FREE(actionNode->node, sizeof(ActionInfo));
5042 RIC_FREE(actionNode, sizeof(CmLList));
5046 /******************************************************************
5048 * @brief Delete Ric subscription action list
5052 * Function : deleteActionSequenceList
5054 * Functionality: Delete Ric subscription action list
5056 * @params[in] Action info list
5060 * ****************************************************************/
5061 void deleteActionSequenceList(CmLListCp *actionList)
5063 CmLList *actionNode=NULLP;
5065 CM_LLIST_FIRST_NODE(actionList, actionNode);
5068 cmLListDelFrm(actionList, actionNode);
5069 deleteActionSequence(actionNode);
5070 CM_LLIST_FIRST_NODE(actionList, actionNode);
5075 /******************************************************************
5077 * @brief Delete Ric subscription node
5081 * Function : deleteRicSubscriptionNode
5083 * Functionality: Delete Ric subscription node
5085 * @params[in] Ric subscription info
5089 * ****************************************************************/
5090 void deleteRicSubscriptionNode(CmLList *subscriptionNode)
5092 RicSubscription *ricSubscriptionInfo = NULLP;
5094 ricSubscriptionInfo = (RicSubscription*)subscriptionNode->node;
5096 deleteActionSequenceList(&ricSubscriptionInfo->actionSequence);
5098 memset(ricSubscriptionInfo, 0, sizeof(RicSubscription));
5099 RIC_FREE(subscriptionNode->node, sizeof(RicSubscription));
5100 RIC_FREE(subscriptionNode, sizeof(CmLList));
5103 /*******************************************************************
5105 * @brief Delete RIC subscription List
5109 * Function : deleteRicSubscriptionList
5111 * Functionality: Delete RIC subscription list
5113 * @params[in] RIC Subscription list
5117 ******************************************************************/
5118 void deleteRicSubscriptionList(CmLListCp *subscriptionList)
5120 CmLList *subscriptionNode = NULLP;
5122 CM_LLIST_FIRST_NODE(subscriptionList, subscriptionNode);
5123 while(subscriptionNode)
5125 cmLListDelFrm(subscriptionList, subscriptionNode);
5126 deleteRicSubscriptionNode(subscriptionNode);
5127 CM_LLIST_FIRST_NODE(subscriptionList, subscriptionNode);
5131 /*******************************************************************
5133 * @brief process the E2 Reset Response
5137 * Function : ProcResetResponse
5139 * Functionality: Process E2 Reset Response
5143 * Pointer to reset response
5146 ******************************************************************/
5148 void ProcResetResponse(uint32_t duId, ResetResponseE2_t *resetRsp)
5150 uint8_t ieIdx = 0, duIdx =0;
5152 RanFunction *ranFuncDb = NULLP;
5153 uint16_t ranFuncIdx = 0;
5155 SEARCH_DU_DB(duIdx, duId, duDb);
5158 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5164 DU_LOG("\nERROR --> E2AP : resetRsp pointer is null");
5168 if(!resetRsp->protocolIEs.list.array)
5170 DU_LOG("\nERROR --> E2AP : resetRsp array pointer is null");
5174 for(ieIdx=0; ieIdx < resetRsp->protocolIEs.list.count; ieIdx++)
5176 if(resetRsp->protocolIEs.list.array[ieIdx])
5178 switch(resetRsp->protocolIEs.list.array[ieIdx]->id)
5180 case ProtocolIE_IDE2_id_TransactionID:
5182 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
5184 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
5185 if(ranFuncDb->id > 0)
5187 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
5192 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5202 /*******************************************************************
5204 * @brief process the E2 Reset Request
5208 * Function : ProcResetRequest
5210 * Functionality: Process E2 Reset Request
5214 * Pointer to reset response
5217 ******************************************************************/
5219 void ProcResetRequest(uint32_t duId, ResetRequestE2_t *resetReq)
5221 uint8_t ieIdx = 0, duIdx =0;
5224 RanFunction *ranFuncDb = NULLP;
5225 uint16_t ranFuncIdx = 0;
5227 SEARCH_DU_DB(duIdx, duId, duDb);
5230 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5236 DU_LOG("\nERROR --> E2AP : resetReq pointer is null");
5240 if(!resetReq->protocolIEs.list.array)
5242 DU_LOG("\nERROR --> E2AP : resetReq array pointer is null");
5246 for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
5248 if(resetReq->protocolIEs.list.array[ieIdx])
5250 switch(resetReq->protocolIEs.list.array[ieIdx]->id)
5252 case ProtocolIE_IDE2_id_TransactionID:
5254 transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5257 case ProtocolIE_IDE2_id_CauseE2:
5259 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
5261 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
5262 if(ranFuncDb->id > 0)
5264 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
5273 if(BuildAndSendResetResponse(duId, transId) !=ROK)
5275 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
5279 /*******************************************************************
5281 * @brief Free RIC Subscription Delete Request Message
5285 * Function : FreeRicSubscriptionDeleteRequest
5287 * Functionality: Free RIC Subscription Delete Request
5289 * @param E2AP Message PDU
5292 ******************************************************************/
5293 void FreeRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
5296 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
5300 if(e2apMsg->choice.initiatingMessage)
5302 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
5303 if(ricSubsDelReq->protocolIEs.list.array)
5305 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
5307 RIC_FREE(ricSubsDelReq->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
5309 RIC_FREE(ricSubsDelReq->protocolIEs.list.array, ricSubsDelReq->protocolIEs.list.size);
5311 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5313 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
5317 /*******************************************************************
5319 * @brief Builds and Send RIC Subscription delete request
5323 * Function : BuildAndSendRicSubscriptionDeleteRequest
5325 * Functionality: Build and send RIC subscription delete request.
5328 * RIC subscription info to be deleted
5329 * @return ROK - success
5332 ******************************************************************/
5333 uint8_t BuildAndSendRicSubscriptionDeleteRequest(uint32_t duId, RicSubscription *ricSubsDb)
5335 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
5336 E2AP_PDU_t *e2apMsg = NULLP;
5337 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
5338 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
5339 asn_enc_rval_t encRetVal; /* Encoder return value */
5343 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Request Message\n");
5345 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5346 if(e2apMsg == NULLP)
5348 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
5352 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5353 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5354 if(e2apMsg->choice.initiatingMessage == NULLP)
5356 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
5359 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
5360 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5361 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest;
5363 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
5366 ricSubsDelReq->protocolIEs.list.count = elementCnt;
5367 ricSubsDelReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequest_IEs_t *);
5369 RIC_ALLOC(ricSubsDelReq->protocolIEs.list.array, ricSubsDelReq->protocolIEs.list.size);
5370 if(ricSubsDelReq->protocolIEs.list.array == NULLP)
5372 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
5376 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5378 RIC_ALLOC(ricSubsDelReq->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequest_IEs_t));
5379 if(ricSubsDelReq->protocolIEs.list.array[ieIdx] == NULLP)
5381 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
5382 __func__, ieIdx, __LINE__);
5386 if(ieIdx < elementCnt)
5389 /* RIC Request ID */
5391 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
5392 ricSubsDelReqIe->id = ProtocolIE_IDE2_id_RICrequestID;
5393 ricSubsDelReqIe->criticality = CriticalityE2_reject;
5394 ricSubsDelReqIe->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RICrequestID;
5395 ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID = ricSubsDb->requestId.requestorId;
5396 ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID = ricSubsDb->requestId.instanceId;
5398 /* RAN Function ID */
5400 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
5401 ricSubsDelReqIe->id = ProtocolIE_IDE2_id_RANfunctionID;
5402 ricSubsDelReqIe->criticality = CriticalityE2_reject;
5403 ricSubsDelReqIe->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RANfunctionID;
5404 ricSubsDelReqIe->value.choice.RANfunctionID = ricSubsDb->ranFuncId;
5406 /* Prints the Msg formed */
5407 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5408 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5410 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5411 if(encRetVal.encoded == ENCODE_FAIL)
5413 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Request Message (at %s)\n",\
5414 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5419 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Request Message \n");
5420 #ifdef DEBUG_ASN_PRINT
5421 for(int i=0; i< encBufSize; i++)
5423 printf("%x",encBuf[i]);
5428 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
5430 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Request Message");
5438 FreeRicSubscriptionDeleteRequest(e2apMsg);
5442 /*******************************************************************
5444 * @brief Processing of RIC Subscription Delete Required
5448 * Function : ProcRicSubsDeleteReqd
5450 * Functionality: Processing of RIC Subscription Delete Required
5451 * When received, RIC stub will initiate the RIC subscription
5452 * deletion procedure towards DU
5455 * RIC Subscription Delete Required IEs
5456 * @return ROK-success
5459 ******************************************************************/
5460 uint8_t ProcRicSubsDeleteReqd(uint32_t duId, RICsubscriptionDeleteRequired_t *ricSubsDelRqd)
5462 uint8_t ieIdx = 0, duIdx = 0;
5463 uint16_t arrIdx = 0;
5465 RicRequestId ricReqId;
5466 RanFunction *ranFuncDb = NULLP;
5467 RicSubscription *subsDb = NULLP;
5468 CmLList *ricSubsNode = NULLP;
5470 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
5471 RICsubscription_List_withCause_t *ricSubsList = NULLP;
5472 RICsubscription_withCause_Item_t *subsItem = NULLP;
5474 memset(&ricReqId, 0, sizeof(RicRequestId));
5478 DU_LOG("\nERROR --> E2AP : %s: Received NULL message", __func__);
5482 SEARCH_DU_DB(duIdx, duId, duDb);
5485 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5489 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
5491 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
5492 switch(ricSubsDelRqdIe->id)
5494 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
5496 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
5497 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
5499 subsItem = &(((RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[arrIdx])->\
5500 value.choice.RICsubscription_withCause_Item);
5501 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, subsItem->ranFunctionID);
5504 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%ld] not found", __func__, subsItem->ranFunctionID);
5508 ricReqId.requestorId = subsItem->ricRequestID.ricRequestorID;
5509 ricReqId.instanceId = subsItem->ricRequestID.ricInstanceID;
5510 subsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
5513 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%ld] Instance_ID [%ld]", \
5514 __func__, subsItem->ricRequestID.ricRequestorID, subsItem->ricRequestID.ricInstanceID);
5518 /* Delete RIC Subcription from RAN Function */
5519 cmLListDelFrm(&ranFuncDb->subscriptionList, ricSubsNode);
5521 /* Send RIC Subscription delete request and then free any memory
5522 * allocated to store subscription info at RIC */
5523 BuildAndSendRicSubscriptionDeleteRequest(duId, (RicSubscription *)ricSubsNode->node);
5524 deleteRicSubscriptionNode(ricSubsNode);
5537 /*******************************************************************
5539 * @brief Deallocate memory allocated for E2nodeConfigurationUpdate
5543 * Function : freeE2NodeConfigItem
5546 * - freeing the memory allocated for E2nodeConfigurationUpdate
5549 * uint8_t protocolIe
5550 * PTR to e2NodeCfg which is to be freed
5551 * @return ROK - success
5554 * ****************************************************************/
5556 void freeE2NodeConfigItem(uint8_t protocolIe, PTR e2NodeCfg)
5558 E2nodeComponentConfigurationAck_t *cfgAck =NULLP;
5559 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULLP;
5560 E2nodeComponentConfigAdditionAck_Item_t *e2NodeAdditionAckItemIe=NULLP;
5561 E2nodeComponentConfigRemovalAck_Item_t *e2NodeRemovalAckItemIe=NULLP;
5562 E2nodeComponentConfigUpdateAck_Item_t *e2NodeUpdateAckItemIe=NULLP;
5564 /* Extracting the component interface and configuration ack information from
5565 * e2NodeCfg based on the protocol id */
5568 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
5570 e2NodeAdditionAckItemIe= (E2nodeComponentConfigAdditionAck_Item_t*)e2NodeCfg;
5571 switch(e2NodeAdditionAckItemIe->e2nodeComponentInterfaceType)
5573 case E2nodeComponentInterfaceType_f1:
5575 f1InterfaceInfo = e2NodeAdditionAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5584 cfgAck = &e2NodeAdditionAckItemIe->e2nodeComponentConfigurationAck;
5587 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
5589 e2NodeUpdateAckItemIe = (E2nodeComponentConfigUpdateAck_Item_t*)e2NodeCfg;
5590 switch(e2NodeUpdateAckItemIe->e2nodeComponentInterfaceType)
5592 case E2nodeComponentInterfaceType_f1:
5594 f1InterfaceInfo = e2NodeUpdateAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5602 cfgAck = &e2NodeUpdateAckItemIe->e2nodeComponentConfigurationAck;
5605 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
5607 e2NodeRemovalAckItemIe= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
5608 switch(e2NodeRemovalAckItemIe->e2nodeComponentInterfaceType)
5610 case E2nodeComponentInterfaceType_f1:
5612 f1InterfaceInfo = e2NodeRemovalAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5620 cfgAck = &e2NodeRemovalAckItemIe->e2nodeComponentConfigurationAck;
5624 /* Freeing the memory allocated to component interface and configuration ack */
5627 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
5628 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
5631 switch(cfgAck->updateOutcome)
5633 case E2nodeComponentConfigurationAck__updateOutcome_success:
5635 case E2nodeComponentConfigurationAck__updateOutcome_failure:
5637 RIC_FREE(cfgAck->failureCauseE2, sizeof(CauseE2_t));
5644 /*******************************************************************
5646 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
5650 * Function : FreeE2NodeConfigUpdate
5653 * - freeing the memory allocated for E2nodeConfigurationUpdate
5655 * @params[in] E2AP_PDU_t *e2apMsg
5656 * @return ROK - success
5659 * ****************************************************************/
5661 void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
5663 uint8_t arrIdx =0, e2NodeConfigIdx=0;
5664 E2nodeConfigurationUpdateAcknowledge_t *updateAckMsg=NULL;
5665 E2nodeComponentConfigUpdateAck_ItemIEs_t *updateAckItemIe=NULL;
5666 E2nodeComponentConfigUpdateAck_List_t *updateAckList=NULL;
5667 E2nodeComponentConfigRemovalAck_ItemIEs_t *removalAckItemIe=NULL;
5668 E2nodeComponentConfigRemovalAck_List_t *removalAckList=NULL;
5669 E2nodeComponentConfigAdditionAck_ItemIEs_t *additionAckItemIte=NULL;
5670 E2nodeComponentConfigAdditionAck_List_t *additionAckList=NULL;
5672 if(e2apMsg != NULLP)
5674 if(e2apMsg->choice.successfulOutcome != NULLP)
5676 updateAckMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
5677 if(updateAckMsg->protocolIEs.list.array != NULLP)
5679 for(arrIdx = 0; arrIdx < updateAckMsg->protocolIEs.list.count; arrIdx++)
5681 if(updateAckMsg->protocolIEs.list.array[arrIdx])
5683 switch(updateAckMsg->protocolIEs.list.array[arrIdx]->id)
5685 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
5687 additionAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
5688 if(additionAckList->list.array)
5690 for(e2NodeConfigIdx=0; e2NodeConfigIdx<additionAckList->list.count; e2NodeConfigIdx++)
5692 additionAckItemIte = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) additionAckList->list.array[e2NodeConfigIdx];
5693 if(additionAckItemIte)
5695 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck,\
5696 (PTR)&additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item);
5697 RIC_FREE(additionAckItemIte, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
5700 RIC_FREE(additionAckList->list.array, additionAckList->list.size);
5704 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
5706 updateAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
5707 if(updateAckList->list.array)
5709 for(e2NodeConfigIdx=0; e2NodeConfigIdx<updateAckList->list.count; e2NodeConfigIdx++)
5711 updateAckItemIe = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) updateAckList->list.array[e2NodeConfigIdx];
5714 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck,\
5715 (PTR)&updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item);
5716 RIC_FREE(updateAckItemIe, sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t));
5719 RIC_FREE(updateAckList->list.array, updateAckList->list.size);
5723 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
5725 removalAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
5726 if(removalAckList->list.array)
5728 for(e2NodeConfigIdx=0; e2NodeConfigIdx<removalAckList->list.count; e2NodeConfigIdx++)
5730 removalAckItemIe = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) removalAckList->list.array[e2NodeConfigIdx];
5731 if(removalAckItemIe)
5733 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck,\
5734 (PTR)&removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item);
5735 RIC_FREE(removalAckItemIe, sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t));
5738 RIC_FREE(removalAckList->list.array, removalAckList->list.size);
5743 RIC_FREE(updateAckMsg->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
5746 RIC_FREE(updateAckMsg->protocolIEs.list.array, updateAckMsg->protocolIEs.list.size);
5748 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
5750 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5754 /*******************************************************************
5756 * @brief Build E2node Component config Removal ack list
5760 * Function : BuildE2nodeComponentConfigRemovalAck
5762 * Functionality: Build the e2 node remove ack
5765 * E2nodeComponentConfigRemovalAck_List_t to be filled
5766 * Count of e2 node to be removed
5767 * list of e2 node cfg to be removed
5769 * @return ROK - success
5771 * ****************************************************************/
5773 uint8_t BuildE2nodeComponentConfigRemovalAck(E2nodeComponentConfigRemovalAck_List_t *e2NodeConfigRemovalAckList,\
5774 uint16_t removalE2NodeCount, E2NodeConfigItem *removaldE2Node)
5777 E2nodeComponentConfigRemovalAck_ItemIEs_t *e2NodeRemovalAckItem=NULL;
5779 /* Filling the e2 node config removal ack list */
5780 e2NodeConfigRemovalAckList->list.count = removalE2NodeCount;
5781 e2NodeConfigRemovalAckList->list.size = e2NodeConfigRemovalAckList->list.count * sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t*);
5782 RIC_ALLOC(e2NodeConfigRemovalAckList->list.array, e2NodeConfigRemovalAckList->list.size);
5783 if(e2NodeConfigRemovalAckList->list.array == NULLP)
5785 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
5789 for(arrIdx = 0; arrIdx< e2NodeConfigRemovalAckList->list.count; arrIdx++)
5791 RIC_ALLOC(e2NodeConfigRemovalAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t));
5792 if(e2NodeConfigRemovalAckList->list.array[arrIdx] == NULLP)
5794 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
5797 e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[arrIdx];
5798 e2NodeRemovalAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck_Item;
5799 e2NodeRemovalAckItem->criticality = CriticalityE2_reject;
5800 e2NodeRemovalAckItem->value.present = E2nodeComponentConfigRemovalAck_ItemIEs__value_PR_E2nodeComponentConfigRemovalAck_Item;
5802 /* Filling the e2 node config removal ack item */
5803 fillE2NodeConfigAck((PTR)&e2NodeRemovalAckItem->value.choice.E2nodeComponentConfigRemovalAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck,\
5804 &removaldE2Node[arrIdx].componentInfo, removaldE2Node[arrIdx].isSuccessful);
5809 /*******************************************************************
5811 * @brief Build E2node Component config update ack list
5815 * Function : BuildE2nodeComponentConfigUpdateAck
5817 * Functionality: Build E2node Component config update ack list
5820 * E2nodeComponentConfigUpdateAck_List to be filled
5821 * Count of e2 node to be update
5822 * list of e2 node cfg to be update
5824 * @return ROK - success
5826 * ****************************************************************/
5828 uint8_t BuildE2nodeComponentConfigUpdateAck(E2nodeComponentConfigUpdateAck_List_t *e2NodeConfigUpdateAckList,\
5829 uint16_t updatedE2NodeCount, E2NodeConfigItem *updatedE2Node)
5832 E2nodeComponentConfigUpdateAck_ItemIEs_t *e2NodeUpdateAckItem=NULL;
5834 /* Filling the e2 node config update ack list */
5835 e2NodeConfigUpdateAckList->list.count = updatedE2NodeCount;
5836 e2NodeConfigUpdateAckList->list.size = e2NodeConfigUpdateAckList->list.count * sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t*);
5837 RIC_ALLOC(e2NodeConfigUpdateAckList->list.array, e2NodeConfigUpdateAckList->list.size);
5838 if(e2NodeConfigUpdateAckList->list.array == NULLP)
5840 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
5844 for(arrIdx = 0; arrIdx< e2NodeConfigUpdateAckList->list.count; arrIdx++)
5846 RIC_ALLOC(e2NodeConfigUpdateAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t));
5847 if(e2NodeConfigUpdateAckList->list.array[arrIdx] == NULLP)
5849 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
5852 e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[arrIdx];
5853 e2NodeUpdateAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck_Item;
5854 e2NodeUpdateAckItem->criticality = CriticalityE2_reject;
5855 e2NodeUpdateAckItem->value.present = E2nodeComponentConfigUpdateAck_ItemIEs__value_PR_E2nodeComponentConfigUpdateAck_Item;
5857 /* Filling the e2 node config update ack item */
5858 fillE2NodeConfigAck((PTR)&e2NodeUpdateAckItem->value.choice.E2nodeComponentConfigUpdateAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck,\
5859 &updatedE2Node[arrIdx].componentInfo, updatedE2Node[arrIdx].isSuccessful);
5865 /*******************************************************************
5867 * @brief Buld and send the E2 node config update ack msg
5871 * Function : BuildAndSendE2NodeConfigUpdateAck
5874 * - Buld and send the E2 node config update ack msg
5878 * list of E2 node cfg which needs to fill in IEs
5879 * @return ROK - success
5882 * ****************************************************************/
5884 uint8_t BuildAndSendE2NodeConfigUpdateAck(DuDb *duDb, uint16_t transId, E2NodeConfigList *e2NodeList)
5886 uint8_t ret = RFAILED;
5887 uint8_t arrIdx = 0,elementCnt = 0;
5888 E2AP_PDU_t *e2apMsg = NULLP;
5889 asn_enc_rval_t encRetVal;
5890 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
5892 DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
5895 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5896 if(e2apMsg == NULLP)
5898 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5901 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
5902 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
5903 if(e2apMsg->choice.successfulOutcome == NULLP)
5905 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5909 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
5910 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
5911 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
5912 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
5915 if(e2NodeList->addedE2NodeCount)
5917 if(e2NodeList->updatedE2NodeCount)
5919 if(e2NodeList->removedE2NodeCount)
5922 e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
5923 e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
5924 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
5925 if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
5927 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5931 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
5933 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
5934 if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
5937 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5942 if(arrIdx<elementCnt)
5946 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5947 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5948 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
5949 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5951 if(e2NodeList->addedE2NodeCount)
5954 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
5955 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5956 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigAdditionAck_List;
5957 if(BuildE2nodeComponentConfigAdditionAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List,\
5958 e2NodeList->addedE2NodeCount, e2NodeList->addedE2Node)!=ROK)
5961 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
5965 if(e2NodeList->updatedE2NodeCount)
5968 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck;
5969 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5970 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigUpdateAck_List;
5971 if(BuildE2nodeComponentConfigUpdateAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List,\
5972 e2NodeList->updatedE2NodeCount, e2NodeList->updatedE2Node)!=ROK)
5975 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config update ack list");
5979 if(e2NodeList->removedE2NodeCount)
5982 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck;
5983 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5984 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigRemovalAck_List;
5985 if(BuildE2nodeComponentConfigRemovalAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List,\
5986 e2NodeList->removedE2NodeCount, e2NodeList->removedE2Node)!=ROK)
5989 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config removal ack list");
5993 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5995 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5997 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
5999 if(encRetVal.encoded == ENCODE_FAIL)
6001 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
6002 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6007 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
6008 for(int i=0; i< encBufSize; i++)
6010 DU_LOG("%x",encBuf[i]);
6016 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
6018 DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
6025 FreeE2NodeConfigUpdateAck(e2apMsg);
6030 /******************************************************************
6032 * @brief Processes the E2 removal failure msg
6036 * Function : procE2RemovalFailure
6038 * Functionality: Processes the E2 removal failure msg
6041 * E2 Removal Failure information
6045 * ****************************************************************/
6046 void ProcE2RemovalFailure(E2RemovalFailure_t *e2RemovalFailure)
6050 CauseE2_t *cause = NULLP;
6052 if(!e2RemovalFailure)
6054 DU_LOG("\nERROR --> E2AP : e2RemovalFailure pointer is null");
6058 if(!e2RemovalFailure->protocolIEs.list.array)
6060 DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
6064 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
6066 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
6068 switch(e2RemovalFailure->protocolIEs.list.array[ieIdx]->id)
6070 case ProtocolIE_IDE2_id_TransactionID:
6072 transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
6073 DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
6076 case ProtocolIE_IDE2_id_CauseE2:
6078 cause = &e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
6079 printE2ErrorCause(cause);
6084 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
6091 /*******************************************************************
6093 * @brief Delete E2 component node list
6097 * Function : deleteE2ComponentNodeList
6099 * Functionality: Delete E2 component node list
6101 * @params[in] E2 component node list
6105 ******************************************************************/
6107 void deleteE2ComponentNodeList(CmLListCp *componentList)
6109 E2NodeComponent *cfgInfo = NULLP;
6110 CmLList *e2ComponentNode = NULLP;
6112 CM_LLIST_FIRST_NODE(componentList, e2ComponentNode);
6113 while(e2ComponentNode)
6115 cfgInfo = (E2NodeComponent*)e2ComponentNode->node;
6116 cmLListDelFrm(componentList, e2ComponentNode);
6117 memset(cfgInfo, 0, sizeof(E2NodeComponent));
6118 CM_LLIST_FIRST_NODE(componentList, e2ComponentNode);
6122 /*******************************************************************
6124 * @brief process the E2 node information from ric db
6128 * Function : deleteE2NodeInfo
6130 * Functionality: process the E2 node information from ric db
6137 ******************************************************************/
6138 void deleteE2NodeInfo(DuDb *duDb)
6140 uint16_t ranFuncIdx =0;
6141 RanFunction *ranFuncDb=NULLP;
6143 DU_LOG("\nINFO --> E2AP : Removing all the E2 node information");
6144 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
6146 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
6147 if(ranFuncDb->id > 0)
6149 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
6152 deleteE2ComponentNodeList(&duDb->e2NodeComponent);
6155 /*******************************************************************
6157 * @brief process the E2 Removal Response
6161 * Function : ProcE2RemovalResponse
6163 * Functionality: Process E2 Removal Response
6167 * Pointer to removal response
6170 ******************************************************************/
6172 void ProcE2RemovalResponse(uint32_t duId, E2RemovalResponse_t *removalRsp)
6174 uint8_t ieIdx = 0, duIdx =0;
6177 SEARCH_DU_DB(duIdx, duId, duDb);
6180 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6186 DU_LOG("\nERROR --> E2AP : removalRsp pointer is null");
6190 if(!removalRsp->protocolIEs.list.array)
6192 DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
6196 for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
6198 if(removalRsp->protocolIEs.list.array[ieIdx])
6200 switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
6202 case ProtocolIE_IDE2_id_TransactionID:
6204 DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
6205 cmInetClose(&sctpCb.e2LstnSockFd);
6206 deleteE2NodeInfo(duDb);
6211 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
6218 /*******************************************************************
6220 * @brief Deallocate the memory allocated for E2 Removal Failure
6224 * Function : FreeE2RemovalFailure
6227 * - freeing the memory allocated for E2RemovalFailure
6229 * @params[in] E2AP_PDU_t *e2apMsg
6232 * ****************************************************************/
6233 void FreeE2RemovalFailure(E2AP_PDU_t *e2apMsg)
6236 E2RemovalFailure_t *e2RemovalFailure=NULLP;
6238 if(e2apMsg != NULLP)
6240 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
6242 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
6243 if(e2RemovalFailure->protocolIEs.list.array)
6245 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
6247 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
6249 RIC_FREE(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
6252 RIC_FREE(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
6254 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
6256 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6260 /*******************************************************************
6262 * @brief Buld and send the E2 Removal Failure msg
6266 * Function : BuildAndSendE2RemovalFailure
6269 * - Buld and send the E2 Removal Failure Message
6275 * @return ROK - success
6278 * ****************************************************************/
6280 uint8_t BuildAndSendRemovalFailure(uint32_t duId, uint16_t transId, CauseE2_PR causePresent, uint8_t reason)
6282 uint8_t ieIdx = 0, elementCnt = 0;
6283 uint8_t ret = RFAILED;
6284 E2AP_PDU_t *e2apMsg = NULLP;
6285 E2RemovalFailure_t *e2RemovalFailure=NULLP;
6286 asn_enc_rval_t encRetVal; /* Encoder return value */
6288 DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
6291 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6292 if(e2apMsg == NULLP)
6294 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6297 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
6299 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
6300 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
6302 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6306 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
6307 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
6308 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure;
6309 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
6312 e2RemovalFailure->protocolIEs.list.count = elementCnt;
6313 e2RemovalFailure->protocolIEs.list.size = elementCnt * sizeof(E2RemovalFailureIEs_t *);
6314 RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
6315 if(!e2RemovalFailure->protocolIEs.list.array)
6317 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6321 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6323 RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
6324 if(!e2RemovalFailure->protocolIEs.list.array[ieIdx])
6326 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6330 if(ieIdx < elementCnt)
6334 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6335 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6336 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = E2RemovalFailureIEs__value_PR_TransactionID;
6337 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
6341 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
6342 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
6343 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
6344 fillE2FailureCause(&e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
6346 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6348 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6350 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6351 if(encRetVal.encoded == ENCODE_FAIL)
6353 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
6354 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6359 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
6360 for(int i=0; i< encBufSize; i++)
6362 DU_LOG("%x",encBuf[i]);
6367 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6369 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Failure");
6377 FreeE2RemovalFailure(e2apMsg);
6381 /*******************************************************************
6383 * @brief Deallocate the memory allocated for E2 Removal Response
6387 * Function : FreeE2RemovalResponse
6390 * - freeing the memory allocated for E2RemovalResponse
6392 * @params[in] E2AP_PDU_t *e2apMsg
6393 * @return ROK - success
6396 * ****************************************************************/
6397 void FreeE2RemovalResponse(E2AP_PDU_t *e2apMsg)
6400 E2RemovalResponse_t *e2RemovalResponse=NULLP;
6402 if(e2apMsg != NULLP)
6404 if(e2apMsg->choice.successfulOutcome != NULLP)
6406 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
6407 if(e2RemovalResponse->protocolIEs.list.array)
6409 for(ieIdx=0; ieIdx < e2RemovalResponse->protocolIEs.list.count; ieIdx++)
6411 if(e2RemovalResponse->protocolIEs.list.array[ieIdx])
6413 RIC_FREE(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
6416 RIC_FREE(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
6418 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6420 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6424 /*******************************************************************
6426 * @brief Buld and send the E2 Removal Response msg
6430 * Function : BuildAndSendE2RemovalResponse
6433 * - Buld and send the E2 Removal Response Message
6437 * @return ROK - success
6440 * ****************************************************************/
6441 uint8_t BuildAndSendRemovalResponse(uint32_t duId, uint16_t transId)
6443 uint8_t ieIdx = 0, elementCnt = 0;
6444 uint8_t ret = RFAILED, duIdx =0;
6445 E2AP_PDU_t *e2apMsg = NULLP;
6447 E2RemovalResponse_t *e2RemovalResponse=NULLP;
6448 asn_enc_rval_t encRetVal; /* Encoder return value */
6450 DU_LOG("\nINFO --> E2AP : Building E2 Removal Response Message\n");
6453 SEARCH_DU_DB(duIdx, duId, duDb);
6456 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6460 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6461 if(e2apMsg == NULLP)
6463 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6466 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
6468 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6469 if(e2apMsg->choice.successfulOutcome == NULLP)
6471 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6475 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
6476 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
6477 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2RemovalResponse;
6478 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
6481 e2RemovalResponse->protocolIEs.list.count = elementCnt;
6482 e2RemovalResponse->protocolIEs.list.size = elementCnt * sizeof(E2RemovalResponseIEs_t *);
6483 RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
6484 if(!e2RemovalResponse->protocolIEs.list.array)
6486 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6490 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6492 RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
6493 if(!e2RemovalResponse->protocolIEs.list.array[ieIdx])
6495 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6499 if(ieIdx < elementCnt)
6503 e2RemovalResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6504 e2RemovalResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6505 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.present = E2RemovalResponseIEs__value_PR_TransactionID;
6506 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
6508 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6510 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6512 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6513 if(encRetVal.encoded == ENCODE_FAIL)
6515 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
6516 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6521 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
6522 for(int i=0; i< encBufSize; i++)
6524 DU_LOG("%x",encBuf[i]);
6529 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6531 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Response");
6539 FreeE2RemovalResponse(e2apMsg);
6543 /*******************************************************************
6545 * @brief Process Removal req received from RIC
6549 * Function : procE2RemovalRequest
6551 * Functionality: Process Removal req received from RIC
6555 * E2 Removal Request
6558 ******************************************************************/
6560 void procE2RemovalRequest(uint32_t duId, E2RemovalRequest_t *removalReq)
6563 uint16_t transId =0;
6565 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
6567 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
6569 switch(removalReq->protocolIEs.list.array[arrIdx]->id)
6571 case ProtocolIE_IDE2_id_TransactionID:
6573 transId = removalReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
6578 DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
6584 if(transId>=0 && transId<=255)
6586 if(BuildAndSendRemovalResponse(duId, transId) != ROK)
6588 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
6593 if(BuildAndSendRemovalFailure(duId, transId, CauseE2_PR_protocol, CauseE2Protocol_abstract_syntax_error_falsely_constructed_message) != ROK)
6595 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
6600 /*******************************************************************
6602 * @brief fill E2 connection update item
6606 * Function : fillE2connectionUpdateItem
6608 * Functionality: fill E2 connection update item
6611 * E2connectionUpdate Item to be filled
6613 * @return ROK - success
6615 * ****************************************************************/
6617 uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId)
6619 E2connectionUpdateRemove_Item_t *connectionRemoveITem=NULLP;
6620 E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
6621 TNLinformation_t *tnlInformation = NULLP;
6622 TNLusage_t *tnlUsage=NULLP;
6626 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
6628 connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
6629 tnlInformation = &connectionModifyItem->tnlInformation;
6630 tnlUsage = &connectionModifyItem->tnlUsage;
6634 case ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item:
6636 connectionRemoveITem = (E2connectionUpdateRemove_Item_t*)connectionInfo;
6637 tnlInformation= &connectionRemoveITem->tnlInformation;
6642 tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
6643 RIC_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
6644 if(!tnlInformation->tnlAddress.buf)
6646 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6650 tnlInformation->tnlAddress.buf[3] = ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr & 0xFF;
6651 tnlInformation->tnlAddress.buf[2] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 8) & 0xFF;
6652 tnlInformation->tnlAddress.buf[1] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 16) & 0xFF;
6653 tnlInformation->tnlAddress.buf[0] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 24) & 0xFF;
6654 tnlInformation->tnlAddress.bits_unused = 0;
6655 if(protocolId == ProtocolIE_IDE2_id_E2connectionUpdate_Item)
6657 *tnlUsage = TNLusage_support_function;
6662 /*******************************************************************
6664 * @brief Build E2 connection modification list
6668 * Function : BuildE2ConnectionModifyList
6670 * Functionality: Build E2 connection modification list
6673 * E2 connection modification list to be filled
6675 * @return ROK - success
6677 * ****************************************************************/
6679 uint8_t BuildE2ConnectionModifyList(E2connectionUpdate_List_t *connectionToBeModifyList)
6682 E2connectionUpdate_ItemIEs_t *connectionModify=NULL;
6684 connectionToBeModifyList->list.count = 1;
6686 connectionToBeModifyList->list.size = connectionToBeModifyList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
6687 RIC_ALLOC(connectionToBeModifyList->list.array, connectionToBeModifyList->list.size);
6688 if(connectionToBeModifyList->list.array)
6690 for(arrIdx = 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
6692 RIC_ALLOC(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
6693 if(connectionToBeModifyList->list.array[arrIdx] == NULLP)
6695 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6698 connectionModify = (E2connectionUpdate_ItemIEs_t*)connectionToBeModifyList->list.array[arrIdx];
6699 connectionModify->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
6700 connectionModify->criticality= CriticalityE2_ignore;
6701 connectionModify->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
6702 if(fillE2connectionUpdateItem((PTR)&connectionModify->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item) != ROK)
6704 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
6712 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6718 /*******************************************************************
6720 * @brief Build E2 connection remove list
6724 * Function : BuildE2ConnectionRemoveList
6726 * Functionality: Build E2 connection remove list
6729 * E2 connection remove list to be filled
6731 * @return ROK - success
6733 * ****************************************************************/
6735 uint8_t BuildE2ConnectionRemoveList(E2connectionUpdateRemove_List_t *connectionToBeRemoveList)
6738 E2connectionUpdateRemove_ItemIEs_t *connectionRemove=NULL;
6740 connectionToBeRemoveList->list.count = 1;
6742 connectionToBeRemoveList->list.size = connectionToBeRemoveList->list.count*sizeof(E2connectionUpdateRemove_ItemIEs_t*);
6743 RIC_ALLOC(connectionToBeRemoveList->list.array, connectionToBeRemoveList->list.size);
6744 if(connectionToBeRemoveList->list.array)
6746 for(arrIdx = 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
6748 RIC_ALLOC(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
6749 if(connectionToBeRemoveList->list.array[arrIdx] == NULLP)
6751 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6754 connectionRemove = (E2connectionUpdateRemove_ItemIEs_t*)connectionToBeRemoveList->list.array[arrIdx];
6755 connectionRemove->id = ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item;
6756 connectionRemove->criticality= CriticalityE2_ignore;
6757 connectionRemove->value.present = E2connectionUpdateRemove_ItemIEs__value_PR_E2connectionUpdateRemove_Item;
6758 if(fillE2connectionUpdateItem((PTR)&connectionRemove->value.choice.E2connectionUpdateRemove_Item, ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item) != ROK)
6760 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
6768 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6774 /*******************************************************************
6776 * @brief Deallocate the memory allocated for E2ConnectionUpdate msg
6780 * Function : FreeE2ConnectionUpdate
6783 * - freeing the memory allocated for E2ConnectionUpdate
6785 * @params[in] E2AP_PDU_t *e2apMsg
6786 * @return ROK - success
6789 * ****************************************************************/
6790 void FreeE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
6792 uint8_t ieIdx =0, arrIdx=0;
6793 E2connectionUpdate_t *connectionUpdate = NULLP;
6794 E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
6795 E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
6797 if(e2apMsg != NULLP)
6799 if(e2apMsg->choice.initiatingMessage != NULLP)
6801 connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
6802 if(connectionUpdate->protocolIEs.list.array)
6804 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
6806 if(connectionUpdate->protocolIEs.list.array[ieIdx])
6808 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
6810 case ProtocolIE_IDE2_id_TransactionID:
6813 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
6815 connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
6816 if(connectionToBeModifyList->list.array)
6818 for(arrIdx = 0; arrIdx < connectionToBeModifyList->list.count; arrIdx++)
6820 RIC_FREE(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
6822 RIC_FREE(connectionToBeModifyList->list.array, connectionToBeModifyList->list.size);
6827 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
6829 connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
6830 if(connectionToBeRemoveList->list.array)
6832 for(arrIdx = 0; arrIdx < connectionToBeRemoveList->list.count; arrIdx++)
6834 RIC_FREE(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
6836 RIC_FREE(connectionToBeRemoveList->list.array, connectionToBeRemoveList->list.size);
6841 RIC_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
6844 RIC_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
6846 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6848 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6852 /*******************************************************************
6854 * @brief Buld and send the E2 Connection Update msg
6858 * Function : BuildAndSendE2ConnectionUpdate
6861 * - Buld and send the E2 Connection Update Message
6864 * E2 connection to be modify or delete
6865 * @return ROK - success
6868 * ****************************************************************/
6870 uint8_t BuildAndSendE2ConnectionUpdate(uint32_t duId, E2Connection connectionInfo)
6872 uint8_t ieIdx = 0, elementCnt = 0;
6873 uint8_t ret = RFAILED, duIdx =0;
6875 E2AP_PDU_t *e2apMsg = NULLP;
6876 E2connectionUpdate_t *e2ConnectionUpdate=NULLP;
6877 asn_enc_rval_t encRetVal; /* Encoder return value */
6879 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Message\n");
6882 SEARCH_DU_DB(duIdx, duId, duDb);
6885 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6889 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6890 if(e2apMsg == NULLP)
6892 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6895 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6897 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6898 if(e2apMsg->choice.initiatingMessage == NULLP)
6900 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6904 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
6905 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6906 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2connectionUpdate;
6907 e2ConnectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
6910 if(connectionInfo == MODIFY_CONNECTION)
6912 if(connectionInfo == REMOVE_CONNECTION)
6915 e2ConnectionUpdate->protocolIEs.list.count = elementCnt;
6916 e2ConnectionUpdate->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdate_IEs_t*);
6917 RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array, e2ConnectionUpdate->protocolIEs.list.size);
6918 if(!e2ConnectionUpdate->protocolIEs.list.array)
6920 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6924 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6926 RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
6927 if(!e2ConnectionUpdate->protocolIEs.list.array[ieIdx])
6929 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6933 if(ieIdx < elementCnt)
6937 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6938 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6939 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_TransactionID;
6940 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = assignTransactionId(duDb);
6942 if(connectionInfo == MODIFY_CONNECTION)
6945 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionUpdateModify;
6946 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6947 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdate_List;
6948 if(BuildE2ConnectionModifyList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List) != ROK)
6950 DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
6955 if(connectionInfo == REMOVE_CONNECTION)
6958 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionUpdateRemove;
6959 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6960 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdateRemove_List;
6961 if(BuildE2ConnectionRemoveList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List) != ROK)
6963 DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
6968 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6970 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6972 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6973 if(encRetVal.encoded == ENCODE_FAIL)
6975 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update structure (at %s)\n",\
6976 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6981 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update \n");
6982 for(int i=0; i< encBufSize; i++)
6984 DU_LOG("%x",encBuf[i]);
6989 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6991 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update");
6999 FreeE2ConnectionUpdate(e2apMsg);
7003 /******************************************************************
7005 * @brief Processes the E2 connection update failure msg
7009 * Function : procE2connectionUpdateFailure
7011 * Functionality: Processes the E2 connection update failure msg
7014 * E2 connection update failure information
7018 * ****************************************************************/
7019 void ProcE2connectionUpdateFailure(E2connectionUpdateFailure_t *updateFailure)
7023 CauseE2_t *cause = NULLP;
7027 DU_LOG("\nERROR --> E2AP : updateFailure pointer is null");
7031 if(!updateFailure->protocolIEs.list.array)
7033 DU_LOG("\nERROR --> E2AP : updateFailure array pointer is null");
7037 for(ieIdx=0; ieIdx < updateFailure->protocolIEs.list.count; ieIdx++)
7039 if(updateFailure->protocolIEs.list.array[ieIdx])
7041 switch(updateFailure->protocolIEs.list.array[ieIdx]->id)
7043 case ProtocolIE_IDE2_id_TransactionID:
7045 transId = updateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
7046 DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
7049 case ProtocolIE_IDE2_id_CauseE2:
7051 cause = &updateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
7052 printE2ErrorCause(cause);
7057 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", updateFailure->protocolIEs.list.array[ieIdx]->id);
7065 /*******************************************************************
7067 * @brief process the E2 Connection update ack
7071 * Function : ProcE2ConnectionUpdateAck
7073 * Functionality: Process E2 Connection update ack
7077 * Pointer to Connection update ack
7080 ******************************************************************/
7082 void ProcE2ConnectionUpdateAck(uint32_t duId, E2connectionUpdateAcknowledge_t *connectionUpdateAck)
7084 uint16_t transId =0;
7085 uint32_t ipAddress=0;
7087 uint8_t ieIdx = 0, duIdx =0, arrIdx=0;
7088 E2connectionUpdate_Item_t *connectionSetupItem=NULLP;
7089 E2connectionUpdate_ItemIEs_t *connectionSetupItemIe=NULLP;
7090 E2connectionUpdate_List_t *connectionSetupList=NULLP;
7091 E2connectionSetupFailed_Item_t *setupFailedItem =NULLP;
7092 E2connectionSetupFailed_List_t *setupFailedList=NULLP;
7093 E2connectionSetupFailed_ItemIEs_t *setupFailedItemIe =NULLP;
7095 SEARCH_DU_DB(duIdx, duId, duDb);
7098 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
7102 if(!connectionUpdateAck)
7104 DU_LOG("\nERROR --> E2AP : connectionUpdateAck pointer is null");
7108 if(!connectionUpdateAck->protocolIEs.list.array)
7110 DU_LOG("\nERROR --> E2AP : connectionUpdateAck array pointer is null");
7114 for(ieIdx=0; ieIdx < connectionUpdateAck->protocolIEs.list.count; ieIdx++)
7116 if(connectionUpdateAck->protocolIEs.list.array[ieIdx])
7118 switch(connectionUpdateAck->protocolIEs.list.array[ieIdx]->id)
7120 case ProtocolIE_IDE2_id_TransactionID:
7122 transId = connectionUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
7125 DU_LOG("\nERROR --> E2AP : Received invalid trans id %d ",transId);
7130 case ProtocolIE_IDE2_id_E2connectionSetup:
7132 connectionSetupList=&connectionUpdateAck->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
7133 if(connectionSetupList->list.array)
7135 for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
7137 connectionSetupItemIe = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
7138 connectionSetupItem = &connectionSetupItemIe->value.choice.E2connectionUpdate_Item;
7139 bitStringToInt(&connectionSetupItem->tnlInformation.tnlAddress, &ipAddress);
7140 if(ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr == ipAddress)
7142 ricCb.ricCfgParams.sctpParams.usage = connectionSetupItem->tnlUsage;
7149 case ProtocolIE_IDE2_id_E2connectionSetupFailed:
7151 setupFailedList=&connectionUpdateAck->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
7152 if(setupFailedList->list.array)
7154 for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
7156 setupFailedItemIe = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
7157 setupFailedItem = &setupFailedItemIe->value.choice.E2connectionSetupFailed_Item;
7158 printE2ErrorCause(&setupFailedItem->cause);
7165 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", connectionUpdateAck->protocolIEs.list.array[ieIdx]->id);
7173 /******************************************************************
7175 * @brief Processes the Ric Subs delete failure msg
7179 * Function : procRicSubsDeleteFailure
7181 * Functionality: Processes the Ric Subs delete failure msg
7184 * Ric Subs delete failure information
7188 * ****************************************************************/
7189 void ProcRicSubsDeleteFailure(RICsubscriptionDeleteFailure_t *ricSubsDeleteFail)
7192 uint16_t ranFuncId=0;
7193 CauseE2_t *cause = NULLP;
7194 RICrequestID_t ricRequestID;
7196 if(!ricSubsDeleteFail)
7198 DU_LOG("\nERROR --> E2AP : ricSubsDeleteFail pointer is null");
7202 if(!ricSubsDeleteFail->protocolIEs.list.array)
7204 DU_LOG("\nERROR --> E2AP : ricSubsDeleteFail array pointer is null");
7208 for(ieIdx=0; ieIdx < ricSubsDeleteFail->protocolIEs.list.count; ieIdx++)
7210 if(ricSubsDeleteFail->protocolIEs.list.array[ieIdx])
7212 switch(ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->id)
7214 case ProtocolIE_IDE2_id_RICrequestID:
7216 memcpy(&ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t));
7217 DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
7220 case ProtocolIE_IDE2_id_RANfunctionID:
7222 ranFuncId = ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
7223 DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId);
7226 case ProtocolIE_IDE2_id_CauseE2:
7228 cause = &ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
7229 printE2ErrorCause(cause);
7234 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->id);
7243 /******************************************************************
7245 * @brief Processes the Ric Subs delete rsp msg
7249 * Function : ProcRicSubsDeleteRsp
7251 * Functionality: Processes the Ric Subs delete rsp msg
7254 * Ric Subs delete rsp information
7258 * ****************************************************************/
7259 void ProcRicSubsDeleteRsp(uint32_t duId, RICsubscriptionDeleteResponse_t *ricSubsDeleteRsp)
7263 uint16_t ranFuncId=0;
7264 RanFunction *ranFuncDb = NULLP;
7265 RicRequestId ricReqId;
7267 RicSubscription *ricSubs = NULLP;
7268 CmLList *ricSubsNode = NULLP;
7270 SEARCH_DU_DB(duIdx, duId, duDb);
7273 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
7277 if(!ricSubsDeleteRsp)
7279 DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp pointer is null");
7283 if(!ricSubsDeleteRsp->protocolIEs.list.array)
7285 DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp array pointer is null");
7288 for(ieIdx=0; ieIdx < ricSubsDeleteRsp->protocolIEs.list.count; ieIdx++)
7290 if(ricSubsDeleteRsp->protocolIEs.list.array[ieIdx])
7292 switch(ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->id)
7294 case ProtocolIE_IDE2_id_RICrequestID:
7296 ricReqId.requestorId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricRequestorID;
7297 ricReqId.instanceId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricInstanceID;
7300 case ProtocolIE_IDE2_id_RANfunctionID:
7302 ranFuncId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
7303 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
7306 DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
7310 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
7313 deleteRicSubscriptionNode(ricSubsNode);
7314 DU_LOG("\nINFO --> E2AP : Ric subscription node deleted successfully");
7318 DU_LOG("\nERROR --> E2AP : Ric subscription node is not present ");
7329 /******************************************************************
7331 * @brief Processes the Ric Subs modification failure msg
7335 * Function : procRicSubsModificationFailure
7337 * Functionality: Processes the Ric Subs modification failure msg
7340 * Ric Subs modification failure information
7344 * ****************************************************************/
7345 void ProcRicSubsModificationFailure(RICsubscriptionModificationFailure_t *ricSubsModificationFail)
7348 uint16_t ranFuncId=0;
7349 CauseE2_t *cause = NULLP;
7350 RICrequestID_t ricRequestID;
7352 DU_LOG("\nINFO --> E2AP : Ric subscription modification failure received");
7354 if(!ricSubsModificationFail)
7356 DU_LOG("\nERROR --> E2AP : ricSubsModificationFail pointer is null");
7360 if(!ricSubsModificationFail->protocolIEs.list.array)
7362 DU_LOG("\nERROR --> E2AP : ricSubsModificationFail array pointer is null");
7366 for(ieIdx=0; ieIdx < ricSubsModificationFail->protocolIEs.list.count; ieIdx++)
7368 if(ricSubsModificationFail->protocolIEs.list.array[ieIdx])
7370 switch(ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id)
7372 case ProtocolIE_IDE2_id_RICrequestID:
7374 memcpy(&ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t));
7375 DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
7378 case ProtocolIE_IDE2_id_RANfunctionID:
7380 ranFuncId = ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
7381 DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId);
7384 case ProtocolIE_IDE2_id_CauseE2:
7386 cause = &ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
7387 printE2ErrorCause(cause);
7392 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id);
7400 /*******************************************************************
7402 * @brief Free RIC Subscription action to be added list
7406 * Function : FreeRicSubsActionToBeAdded
7408 * Functionality: Free the RIC Subscription action to be added list
7410 * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
7413 * ****************************************************************/
7414 void FreeRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
7416 uint8_t elementIdx = 0;
7417 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
7419 if(subsDetails->list.array)
7421 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
7423 if(subsDetails->list.array[elementIdx])
7425 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
7426 RIC_FREE(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf, \
7427 addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.size);
7428 RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t));
7431 RIC_FREE(subsDetails->list.array, subsDetails->list.size);
7435 /*******************************************************************
7437 * @brief Free RIC Subscription action to be removed list
7441 * Function : FreeRicSubsActionToBeRemoved
7443 * Functionality: Free the RIC Subscription action to be removed list
7445 * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
7448 * ****************************************************************/
7449 void FreeRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
7451 uint8_t elementIdx = 0;
7453 if(subsDetails->list.array)
7455 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
7457 RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t));
7459 RIC_FREE(subsDetails->list.array, subsDetails->list.size);
7463 /*******************************************************************
7465 * @brief Free RIC Subscription action to be modify
7469 * Function : FreeRicSubsActionToBeModified
7471 * Functionality: Free the RIC Subscription action to be modify
7473 * @params[in] RICactions_ToBeModifiedForModification_List_t List
7476 * ****************************************************************/
7477 void FreeRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
7479 uint8_t elementIdx = 0;
7480 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
7482 if(subsDetails->list.array)
7484 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
7486 if(subsDetails->list.array[elementIdx])
7488 actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx];
7489 if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
7491 RIC_FREE(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf, \
7492 actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->size);
7493 RIC_FREE(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
7495 RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t))
7498 RIC_FREE(subsDetails->list.array, subsDetails->list.size);
7502 /*******************************************************************
7504 * @brief Free RIC Subscription modification Request
7508 * Function :FreeRicSubscriptionModReq
7510 * Functionality : Free RIC Subscription modification Request
7512 * @params[in] E2AP_PDU
7515 ******************************************************************/
7516 void FreeRicSubscriptionModReq(E2AP_PDU_t *e2apRicMsg)
7519 RICsubscriptionModificationRequest_t *ricSubscriptionModReq =NULLP;
7520 RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe=NULLP;
7524 if(e2apRicMsg->choice.initiatingMessage)
7526 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
7527 if(ricSubscriptionModReq->protocolIEs.list.array)
7529 for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
7531 if(ricSubscriptionModReq->protocolIEs.list.array[idx])
7533 ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
7534 switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
7536 case ProtocolIE_IDE2_id_RICrequestID:
7538 case ProtocolIE_IDE2_id_RANfunctionID:
7540 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
7542 FreeRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
7545 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
7547 FreeRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
7550 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
7552 FreeRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
7557 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
7563 RIC_FREE(ricSubscriptionModReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionModificationRequest_IEs_t));
7566 RIC_FREE(ricSubscriptionModReq->protocolIEs.list.array, ricSubscriptionModReq->protocolIEs.list.size);
7568 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7570 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
7574 /*******************************************************************
7576 * @brief Build Ric subscription action to be modify list
7580 * Function : BuildRicSubsActionToBeModify
7582 * Functionality: Build Ric subscription action to be modify list
7585 * RICactions_ToBeModifiedForModification_List_t to be filled
7586 * Num of action to be modify
7587 * List of action to be modify
7589 * @return ROK - success
7592 ******************************************************************/
7594 uint8_t BuildRicSubsActionToBeModify(RICactions_ToBeModifiedForModification_List_t *modifyActionList, uint8_t numOfActionToBeModify, ActionInfo *actionToBeModify)
7597 RICaction_ToBeModifiedForModification_ItemIEs_t *modifiedActionItemIe=NULLP;
7599 modifyActionList->list.count = numOfActionToBeModify;
7600 modifyActionList->list.size = modifyActionList->list.count * sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t*);
7601 RIC_ALLOC(modifyActionList->list.array, modifyActionList->list.size);
7602 if(!modifyActionList->list.array)
7604 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7608 for(arrIdx = 0; arrIdx< modifyActionList->list.count; arrIdx++)
7610 RIC_ALLOC(modifyActionList->list.array[arrIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t));
7611 if(!modifyActionList->list.array[arrIdx])
7613 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7616 modifiedActionItemIe = (RICaction_ToBeModifiedForModification_ItemIEs_t*)modifyActionList->list.array[arrIdx];
7617 modifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item;
7618 modifiedActionItemIe->criticality = CriticalityE2_ignore;
7619 modifiedActionItemIe->value.present = RICaction_ToBeModifiedForModification_ItemIEs__value_PR_RICaction_ToBeModifiedForModification_Item;
7620 modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID = actionToBeModify[arrIdx].actionId;
7622 /* RIC Action Definition */
7623 RIC_ALLOC(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
7624 if(!modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
7626 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7630 if(fillRicActionDef(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition,\
7631 actionToBeModify[arrIdx].actionId, CONFIG_MOD) != ROK)
7633 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7641 /*******************************************************************
7643 * @brief Build Ric subscription action to be removed list
7647 * Function : BuildRicSubsActionToBeRemoved
7649 * Functionality: Build Ric subscription action to be removed list
7652 * RICactions_ToBeRemovedForModification_List_t to be filled
7653 * Num Of Action To Be Remove
7654 * Action remove list
7656 * @return ROK - success
7659 ******************************************************************/
7661 uint8_t BuildRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *removeActionList, uint8_t numOfActionToBeRemove, ActionInfo *actionToBeRemove)
7664 RICaction_ToBeRemovedForModification_ItemIEs_t *removeActionItemIe=NULLP;
7666 removeActionList->list.count = numOfActionToBeRemove;
7667 removeActionList->list.size = removeActionList->list.count * sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t*);
7668 RIC_ALLOC(removeActionList->list.array, removeActionList->list.size);
7669 if(!removeActionList->list.array)
7671 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7675 for(arrIdx = 0; arrIdx< removeActionList->list.count; arrIdx++)
7677 RIC_ALLOC(removeActionList->list.array[arrIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t));
7678 if(!removeActionList->list.array[arrIdx])
7680 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7683 removeActionItemIe = (RICaction_ToBeRemovedForModification_ItemIEs_t*)removeActionList->list.array[arrIdx];
7684 removeActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item;
7685 removeActionItemIe->criticality = CriticalityE2_ignore;
7686 removeActionItemIe->value.present = RICaction_ToBeRemovedForModification_ItemIEs__value_PR_RICaction_ToBeRemovedForModification_Item;
7687 removeActionItemIe->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID = actionToBeRemove[arrIdx].actionId;
7692 /*******************************************************************
7694 * @brief Build Ric subscription action to be added list
7698 * Function : BuildRicSubsActionToBeAdded
7700 * Functionality: Build Ric subscription action to be added list
7703 * RICactions_ToBeAddedForModification_List_t to be filled
7704 * Num Of Action To Be added
7707 * @return ROK - success
7710 ******************************************************************/
7712 uint8_t BuildRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *addedActionList, RicSubscription **ricSubsInfo, uint8_t numOfActionToBeAdded, ActionInfo *actionToBeAdded)
7715 CmLList *actionNode=NULLP;
7716 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe;
7718 addedActionList->list.count = numOfActionToBeAdded;
7719 addedActionList->list.size = addedActionList->list.count * sizeof(RICaction_ToBeAddedForModification_ItemIEs_t*);
7720 RIC_ALLOC(addedActionList->list.array, addedActionList->list.size);
7721 if(!addedActionList->list.array)
7723 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7727 for(arrIdx = 0; arrIdx< addedActionList->list.count; arrIdx++)
7729 RIC_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t));
7730 if(!addedActionList->list.array[arrIdx])
7732 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7735 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx];
7736 addedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item;
7737 addedActionItemIe->criticality = CriticalityE2_ignore;
7738 addedActionItemIe->value.present = RICaction_ToBeAddedForModification_ItemIEs__value_PR_RICaction_ToBeAddedForModification_Item;
7739 addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionID = actionToBeAdded[arrIdx].actionId;
7741 addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionType = RICactionType_report;
7743 if(fillRicActionDef(&addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition, \
7744 actionToBeAdded[arrIdx].actionId, CONFIG_ADD) != ROK)
7746 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7750 actionNode = addRicSubsAction((*ricSubsInfo)->actionSequence.count, &(*ricSubsInfo)->actionSequence);
7751 if(actionNode == NULLP)
7753 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7760 /*******************************************************************
7762 * @brief Builds and Send the RicSubscriptionModReq
7766 * Function : BuildAndSendRicSubscriptionModReq
7768 * Functionality:Builds and Send the RicSubscriptionModReq
7772 * Ric subs information
7773 * List of ric subs action which needs to modify/add/remove
7774 * @return ROK - success
7777 ******************************************************************/
7779 uint8_t BuildAndSendRicSubscriptionModReq(DuDb *duDb, RicSubscription **ricSubsInfo, RicSubsModReq ricSubsModReq)
7781 uint8_t ret = RFAILED;
7782 uint8_t elementCnt = 0;
7784 asn_enc_rval_t encRetVal; /* Encoder return value */
7785 E2AP_PDU_t *e2apRicMsg = NULL;
7786 RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
7788 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
7792 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
7793 if(e2apRicMsg == NULLP)
7795 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7799 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
7800 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7801 if(e2apRicMsg->choice.initiatingMessage == NULLP)
7803 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7806 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
7807 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
7808 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest;
7810 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
7812 /* Increasing the elment count based on the number of configured action to be add, mod, delete */
7814 if(ricSubsModReq.numOfActionToBeAdded)
7816 if(ricSubsModReq.numOfActionToBeModify)
7818 if(ricSubsModReq.numOfActionToBeRemove)
7821 ricSubscriptionModReq->protocolIEs.list.count = elementCnt;
7822 ricSubscriptionModReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequest_IEs_t);
7824 /* Initialize the subscription members */
7825 RIC_ALLOC(ricSubscriptionModReq->protocolIEs.list.array, ricSubscriptionModReq->protocolIEs.list.size);
7826 if(ricSubscriptionModReq->protocolIEs.list.array == NULLP)
7828 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7832 for(idx=0; idx<elementCnt; idx++)
7834 RIC_ALLOC(ricSubscriptionModReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionModificationRequest_IEs_t));
7835 if(ricSubscriptionModReq->protocolIEs.list.array[idx] == NULLP)
7837 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7841 if(idx < elementCnt)
7844 /* Filling RIC Request Id */
7846 ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
7847 ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
7848 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present =\
7849 RICsubscriptionModificationRequest_IEs__value_PR_RICrequestID;
7850 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = (*ricSubsInfo)->requestId.requestorId;
7851 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = (*ricSubsInfo)->requestId.instanceId;
7853 /* Filling RAN Function Id */
7855 ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
7856 ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
7857 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present =\
7858 RICsubscriptionModificationRequest_IEs__value_PR_RANfunctionID;
7859 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = (*ricSubsInfo)->ranFuncId;
7861 if(ricSubsModReq.numOfActionToBeRemove)
7863 /* Filling RIC Subscription action to be removed */
7865 ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List;
7866 ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore;
7867 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeRemovedForModification_List;
7868 if(BuildRicSubsActionToBeRemoved(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeRemovedForModification_List,\
7869 ricSubsModReq.numOfActionToBeRemove, ricSubsModReq.actionToBeRemove) != ROK)
7871 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7875 if(ricSubsModReq.numOfActionToBeModify)
7877 /* Filling RIC Subscription action to be modified */
7879 ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List;
7880 ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore;
7881 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeModifiedForModification_List;
7882 if(BuildRicSubsActionToBeModify(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeModifiedForModification_List,\
7883 ricSubsModReq.numOfActionToBeModify, ricSubsModReq.actionToBeModify) != ROK)
7885 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7890 if(ricSubsModReq.numOfActionToBeAdded)
7892 /* Filling RIC Subscription action to be added */
7894 ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List;
7895 ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore;
7896 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeAddedForModification_List;
7897 if(BuildRicSubsActionToBeAdded(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeAddedForModification_List,\
7898 ricSubsInfo, ricSubsModReq.numOfActionToBeAdded, ricSubsModReq.actionToBeAdded) != ROK)
7900 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7905 /* Prints the Msg formed */
7906 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
7908 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7910 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
7911 if(encRetVal.encoded == ENCODE_FAIL)
7913 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionModRequest structure (at %s)\n",\
7914 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7919 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionModRequest\n");
7920 for(int i=0; i< encBufSize; i++)
7922 DU_LOG("%x",encBuf[i]);
7927 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
7929 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
7937 FreeRicSubscriptionModReq(e2apRicMsg);
7941 /*******************************************************************
7943 * @brief Builds RicSubscriptionModReq
7947 * Function : BuildRicSubscriptionModReq
7949 * Functionality:Builds the RicSubscriptionModReq
7955 * ****************************************************************/
7957 void BuildRicSubsModificationReq(DuDb *duDb, RicSubscription *ricSubsInfo)
7959 CmLList *actionNode=NULLP;
7960 uint8_t actionToBeAdded =0;
7961 uint8_t actionIdx =0, tmpActionIdx=0;
7962 ActionInfo *actionInfoDb = NULLP;
7963 RicSubsModReq ricSubsModReq;
7967 memset(&ricSubsModReq, 0, sizeof(RicSubsModReq));
7970 CM_LLIST_FIRST_NODE(&ricSubsInfo->actionSequence, actionNode);
7973 actionInfoDb = (ActionInfo*)(actionNode->node);
7974 /* Change the condition based on the action required to be modiified or removed */
7975 if(((actionInfoDb->actionId+1)%2) == 0)
7977 tmpActionIdx = ricSubsModReq.numOfActionToBeModify;
7978 ricSubsModReq.actionToBeModify[tmpActionIdx].actionId = actionInfoDb->actionId;
7979 ricSubsModReq.numOfActionToBeModify++;
7983 tmpActionIdx = ricSubsModReq.numOfActionToBeRemove;
7984 ricSubsModReq.actionToBeRemove[tmpActionIdx].actionId = actionInfoDb->actionId;
7985 ricSubsModReq.numOfActionToBeRemove++;
7987 actionNode= actionNode->next;
7989 /* Change the value of actionToBeAdded based on the number of action required to be added */
7991 tmpActionIdx = ricSubsInfo->actionSequence.count;
7992 for(actionIdx=0; actionIdx<actionToBeAdded; actionIdx++)
7994 ricSubsModReq.actionToBeAdded[actionIdx].actionId = tmpActionIdx;
7995 ricSubsModReq.numOfActionToBeAdded++;
7999 if(BuildAndSendRicSubscriptionModReq(duDb, &ricSubsInfo, ricSubsModReq) != ROK)
8001 DU_LOG("\nERROR --> E2AP : failed to build and send RIC Subscription Modification");
8007 /****************************************************************
8009 * @brief Processing RIC Subscription action modified list
8013 * Function :ProcessingRicSubsActionModified
8015 * Functionality: Processing the RIC Subscription action modified list
8017 * @params[in] RICactions_AddedForModification_List_t
8020 * ****************************************************************/
8021 void ProcessingRicSubsActionModified(RICactions_ModifiedForModification_List_t *actionModifiedList)
8024 uint8_t elementIdx = 0;
8025 RICaction_ModifiedForModification_ItemIEs_t *modifiedActionItemIe =NULLP;
8027 if(actionModifiedList->list.array)
8029 for(elementIdx = 0; elementIdx < actionModifiedList->list.count; elementIdx++)
8031 if(actionModifiedList->list.array[elementIdx])
8033 modifiedActionItemIe=(RICaction_ModifiedForModification_ItemIEs_t*)actionModifiedList->list.array[elementIdx];
8034 actionId = modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID;
8035 DU_LOG("\nInfo --> E2AP : Action id %d modified successfully", actionId);
8043 /****************************************************************
8045 * @brief Processing RIC Subscription action added list
8049 * Function : ProcessingRicSubsActionAdded
8051 * Functionality: Processing RIC Subscription action added list
8053 * @params[in] RICactions_AddedForModification_List_t
8056 * ****************************************************************/
8057 void ProcessingRicSubsActionAdded(RICactions_AddedForModification_List_t *actionAddedList)
8060 uint8_t elementIdx = 0;
8061 RICaction_AddedForModification_ItemIEs_t *addedActionItemIe =NULLP;
8063 if(actionAddedList->list.array)
8065 for(elementIdx = 0; elementIdx < actionAddedList->list.count; elementIdx++)
8067 if(actionAddedList->list.array[elementIdx])
8069 addedActionItemIe=(RICaction_AddedForModification_ItemIEs_t*)actionAddedList->list.array[elementIdx];
8070 actionId = addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID;
8071 DU_LOG("\nInfo --> E2AP : Action id %d added successfully", actionId);
8079 /****************************************************************
8081 * @brief Processing RIC Subscription action deleted list
8085 * Function : ProcessingRicSubsActionRemoved
8087 * Functionality: Processing RIC Subscription action deleted list
8089 * @params[in] RICactions_RemovedForModification_List_t
8090 * Ric Subscription info
8093 * ****************************************************************/
8094 void ProcessingRicSubsActionRemoved(RICactions_RemovedForModification_List_t *actionRemovedList, RicSubscription *ricSubs)
8097 uint8_t elementIdx = 0;
8098 ActionInfo *action=NULLP;
8099 CmLList *actionNode =NULLP;
8100 RICaction_RemovedForModification_ItemIEs_t *removedActionItemIe =NULLP;
8102 if(actionRemovedList->list.array)
8104 for(elementIdx = 0; elementIdx < actionRemovedList->list.count; elementIdx++)
8106 if(actionRemovedList->list.array[elementIdx])
8108 removedActionItemIe=(RICaction_RemovedForModification_ItemIEs_t*)actionRemovedList->list.array[elementIdx];
8109 actionId = removedActionItemIe->value.choice.RICaction_RemovedForModification_Item.ricActionID;
8110 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
8113 cmLListDelFrm(&ricSubs->actionSequence, actionNode);
8114 deleteActionSequence(actionNode);
8115 DU_LOG("\nInfo --> E2AP : Action id %d removed successfully", actionId);
8124 /*******************************************************************
8126 * @brief Processing RIC Subscription action failed to be
8131 * Function : ProcessingRicSubsActionFailedToBeRemoved
8133 * Functionality: Processing the RIC Subscription action failed
8134 * to be removed list
8136 * @params[in] RICactions_FailedToBeRemovedForModification_List_t
8139 * ****************************************************************/
8140 void ProcessingRicSubsActionFailedToBeRemoved(RICactions_FailedToBeRemovedForModification_List_t *actionFailedToBeRemoved)
8143 uint8_t elementIdx = 0;
8144 RICaction_FailedToBeRemovedForModification_ItemIEs_t *failedToBeRemovedActionItemIe =NULLP;
8146 if(actionFailedToBeRemoved->list.array)
8148 for(elementIdx = 0; elementIdx < actionFailedToBeRemoved->list.count; elementIdx++)
8150 if(actionFailedToBeRemoved->list.array[elementIdx])
8152 failedToBeRemovedActionItemIe=(RICaction_FailedToBeRemovedForModification_ItemIEs_t*)actionFailedToBeRemoved->list.array[elementIdx];
8153 actionId = failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID;
8154 DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId, __func__);
8155 printE2ErrorCause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause);
8163 /****************************************************************
8165 * @brief Processing RIC Subscription action failed to be
8170 * Function : ProcessingRicSubsActionFailedToBeAdded
8172 * Functionality: Processing the RIC Subscription action failed
8175 * @params[in] RICactions_FailedToBeAddedForModification_List_t
8178 * ****************************************************************/
8179 void ProcessingRicSubsActionFailedToBeAdded(RICactions_FailedToBeAddedForModification_List_t *actionfailedToBeAddedList, RicSubscription *ricSubs)
8182 uint8_t elementIdx = 0;
8183 ActionInfo *action=NULLP;
8184 CmLList *actionNode =NULLP;
8185 RICaction_FailedToBeAddedForModification_ItemIEs_t *failedToBeAddedActionItemIe =NULLP;
8187 if(actionfailedToBeAddedList->list.array)
8189 for(elementIdx = 0; elementIdx < actionfailedToBeAddedList->list.count; elementIdx++)
8191 if(actionfailedToBeAddedList->list.array[elementIdx])
8193 failedToBeAddedActionItemIe=(RICaction_FailedToBeAddedForModification_ItemIEs_t*)actionfailedToBeAddedList->list.array[elementIdx];
8194 actionId = failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.ricActionID;
8195 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
8198 cmLListDelFrm(&ricSubs->actionSequence, actionNode);
8199 deleteActionSequence(actionNode);
8201 DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__);
8202 printE2ErrorCause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause);
8210 /*******************************************************************
8212 * @brief Processing RIC Subscription action failed to be
8217 * Function :ProcessingRicSubsActionFailedToBeModified
8219 * Functionality: Processing the RIC Subscription action failed
8220 * to be modified list
8222 * @params[in] RICactions_FailedToBeModifiedForModification_List_t
8225 * ****************************************************************/
8226 void ProcessingRicSubsActionFailedToBeModified(RICactions_FailedToBeModifiedForModification_List_t *actionFailedToBeModifiedList)
8229 uint8_t elementIdx = 0;
8230 RICaction_FailedToBeModifiedForModification_ItemIEs_t *failedToBeModifiedActionItemIe =NULLP;
8232 if(actionFailedToBeModifiedList->list.array)
8234 for(elementIdx = 0; elementIdx < actionFailedToBeModifiedList->list.count; elementIdx++)
8236 if(actionFailedToBeModifiedList->list.array[elementIdx])
8238 failedToBeModifiedActionItemIe=(RICaction_FailedToBeModifiedForModification_ItemIEs_t*)actionFailedToBeModifiedList->list.array[elementIdx];
8239 actionId = failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID;
8240 DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__);
8241 printE2ErrorCause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause);
8249 /******************************************************************
8251 * @brief Processes the Ric Subs modification rsp msg
8255 * Function : ProcRicSubsModificationRsp
8257 * Functionality: Processes the Ric Subs modification rsp msg
8260 * Ric Subs modification rsp information
8264 * ****************************************************************/
8265 void ProcRicSubsModificationRsp(uint32_t duId, RICsubscriptionModificationResponse_t *ricSubsModificationRsp)
8269 uint16_t ranFuncId=0;
8270 RanFunction *ranFuncDb = NULLP;
8271 RicRequestId ricReqId;
8273 RicSubscription *ricSubs = NULLP;
8274 CmLList *ricSubsNode = NULLP;
8276 SEARCH_DU_DB(duIdx, duId, duDb);
8279 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
8283 if(!ricSubsModificationRsp)
8285 DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp pointer is null");
8289 if(!ricSubsModificationRsp->protocolIEs.list.array)
8291 DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp array pointer is null");
8295 for(ieIdx=0; ieIdx < ricSubsModificationRsp->protocolIEs.list.count; ieIdx++)
8297 if(ricSubsModificationRsp->protocolIEs.list.array[ieIdx])
8299 switch(ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id)
8301 case ProtocolIE_IDE2_id_RICrequestID:
8303 ricReqId.requestorId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricRequestorID;
8304 ricReqId.instanceId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricInstanceID;
8307 case ProtocolIE_IDE2_id_RANfunctionID:
8309 ranFuncId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
8310 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
8313 DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
8317 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
8320 DU_LOG("\nERROR --> E2AP : Ric subscription node is not present ");
8325 case ProtocolIE_IDE2_id_RICactionsRemovedForModification_List:
8327 ProcessingRicSubsActionRemoved(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_RemovedForModification_List, ricSubs);
8330 case ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List:
8332 ProcessingRicSubsActionFailedToBeRemoved(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeRemovedForModification_List);
8335 case ProtocolIE_IDE2_id_RICactionsModifiedForModification_List:
8337 ProcessingRicSubsActionModified(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_ModifiedForModification_List);
8340 case ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List:
8342 ProcessingRicSubsActionFailedToBeModified(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeModifiedForModification_List);
8345 case ProtocolIE_IDE2_id_RICactionsAddedForModification_List:
8347 ProcessingRicSubsActionAdded(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_AddedForModification_List);
8350 case ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List:
8352 ProcessingRicSubsActionFailedToBeAdded(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeAddedForModification_List, ricSubs);
8357 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id);
8365 /*******************************************************************
8367 * @brief Handles received E2AP message and sends back response
8371 * Function : E2APMsgHdlr
8374 * - Decodes received E2AP control message
8375 * - Prepares response message, encodes and sends to SCTP
8378 * @return ROK - success
8381 * ****************************************************************/
8382 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
8388 E2AP_PDU_t *e2apMsg;
8389 asn_dec_rval_t rval; /* Decoder return value */
8390 E2AP_PDU_t e2apasnmsg ;
8392 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
8393 ODU_PRINT_MSG(mBuf, 0,0);
8395 /* Copy mBuf into char array to decode it */
8396 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
8397 RIC_ALLOC(recvBuf, (Size)recvBufLen);
8399 if(recvBuf == NULLP)
8401 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
8404 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
8406 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
8410 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
8411 for(i=0; i< recvBufLen; i++)
8413 DU_LOG("%x",recvBuf[i]);
8416 /* Decoding flat buffer into E2AP messsage */
8417 e2apMsg = &e2apasnmsg;
8418 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
8420 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
8421 RIC_FREE(recvBuf, (Size)recvBufLen);
8423 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
8425 DU_LOG("\nERROR --> E2AP : ASN decode failed");
8429 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8431 switch(e2apMsg->present)
8433 case E2AP_PDU_PR_initiatingMessage:
8435 switch(e2apMsg->choice.initiatingMessage->value.present)
8437 case InitiatingMessageE2__value_PR_E2setupRequest:
8439 DU_LOG("\nINFO --> E2AP : E2 setup request received");
8440 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
8443 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
8445 DU_LOG("\nINFO --> E2AP : E2 node config update received");
8446 ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate);
8449 case InitiatingMessageE2__value_PR_ResetRequestE2:
8451 DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
8452 ProcResetRequest(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
8455 case InitiatingMessageE2__value_PR_RICindication:
8457 DU_LOG("\nINFO --> E2AP : RIC Indication received");
8460 case InitiatingMessageE2__value_PR_RICserviceUpdate:
8462 DU_LOG("\nINFO --> E2AP : RIC Service update received");
8463 ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate);
8466 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired:
8468 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Required");
8469 ProcRicSubsModReqd(*duId, \
8470 &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired);
8473 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired:
8475 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Required");
8476 ProcRicSubsDeleteReqd(*duId, \
8477 &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired);
8481 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
8483 DU_LOG("\nINFO --> E2AP : Error indication received");
8486 case InitiatingMessageE2__value_PR_E2RemovalRequest:
8488 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
8489 procE2RemovalRequest(*duId,\
8490 &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest);
8495 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \
8496 e2apMsg->choice.initiatingMessage->value.present);
8499 }/* End of switch(initiatingMessage) */
8502 case E2AP_PDU_PR_successfulOutcome:
8504 switch(e2apMsg->choice.successfulOutcome->value.present)
8506 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
8508 DU_LOG("\nINFO --> E2AP : Reset response received");
8509 ProcResetResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2);
8512 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
8514 ProcRicSubscriptionResponse(*duId, \
8515 &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse);
8518 case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
8520 ProcE2RemovalResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse);
8523 case SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge:
8525 ProcE2ConnectionUpdateAck(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge);
8528 case SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse:
8530 ProcRicSubsDeleteRsp(*duId, &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse);
8533 case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationResponse:
8535 ProcRicSubsModificationRsp(*duId, &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse);
8540 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \
8541 e2apMsg->choice.successfulOutcome->value.present);
8548 case E2AP_PDU_PR_unsuccessfulOutcome:
8550 switch(e2apMsg->choice.successfulOutcome->value.present)
8552 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure:
8554 ProcRicSubscriptionFailure(*duId, \
8555 &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure);
8558 case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
8560 ProcE2RemovalFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure);
8563 case UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure:
8565 ProcE2connectionUpdateFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure);
8568 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteFailure:
8570 ProcRicSubsDeleteFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure);
8573 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure:
8575 ProcRicSubsModificationFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure);
8580 DU_LOG("\nERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \
8581 e2apMsg->choice.unsuccessfulOutcome->value.present);
8589 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
8593 }/* End of switch(e2apMsg->present) */
8594 } /* End of E2APMsgHdlr */
8597 /**********************************************************************
8599 **********************************************************************/