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, transId = 0;
337 uint8_t ret = RFAILED;
338 E2AP_PDU_t *e2apMsg = NULLP;
339 E2RemovalRequest_t *removalReq = NULLP;
340 asn_enc_rval_t encRetVal; /* Encoder return value */
342 DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
346 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
349 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
353 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
354 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
355 if(e2apMsg->choice.initiatingMessage == NULLP)
357 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
361 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2removal;
362 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
363 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2RemovalRequest;
364 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
367 removalReq->protocolIEs.list.count = elementCnt;
368 removalReq->protocolIEs.list.size = elementCnt * sizeof(E2RemovalRequestIEs_t *);
370 RIC_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
371 if(!removalReq->protocolIEs.list.array)
373 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
377 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
379 RIC_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
380 if(!removalReq->protocolIEs.list.array[ieIdx])
382 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
387 /* In case of failure */
388 if(ieIdx < elementCnt)
392 removalReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
393 removalReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
394 removalReq->protocolIEs.list.array[ieIdx]->value.present = E2RemovalRequestIEs__value_PR_TransactionID;
395 transId = assignTransactionId(duDb);
396 removalReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
398 /* Prints the Msg formed */
399 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
401 memset(encBuf, 0, ENC_BUF_MAX_LEN);
403 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
405 if(encRetVal.encoded == ENCODE_FAIL)
407 DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
408 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
413 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
414 #ifdef DEBUG_ASN_PRINT
415 for(int i=0; i< encBufSize; i++)
417 printf("%x",encBuf[i]);
421 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
423 DU_LOG("\nERROR --> E2AP : Sending removal request failed");
432 /* Free all memory */
433 FreeRemovalRequest(e2apMsg);
437 /*******************************************************************
439 * @brief Fetches RAN Function DB
443 * Function : fetchRanFuncFromRanFuncId
445 * Functionality: Fetches RAN function DB from E2AP DB using
448 * @params[in] RAN Function ID
449 * @return RAN Function DB
450 * NULL, in case of failure
452 * ****************************************************************/
453 RanFunction *fetchRanFuncFromRanFuncId(DuDb *duDb, uint16_t ranFuncId)
455 RanFunction *ranFuncDb = NULLP;
457 /* Fetch RAN Function DB */
458 if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
460 ranFuncDb = &duDb->ranFunction[ranFuncId-1];
464 DU_LOG("\nERROR --> DU_APP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId);
470 /*******************************************************************
472 * @brief Fetch subscripton DB
476 * Function : fetchSubsInfoFromRicReqId
478 * Functionality: Fetches subscription DB from RAN Function DB
479 * using RIC Request ID
481 * @params[in] RIC Request ID
483 * Pointer to RIC Subscription node to be searched
484 * @return RIC Subscription from RAN Function's subcription list
485 * NULL, in case of failure
487 * ****************************************************************/
488 RicSubscription *fetchSubsInfoFromRicReqId(RicRequestId ricReqId, RanFunction *ranFuncDb, CmLList **ricSubscriptionNode)
490 RicSubscription *ricSubscriptionInfo = NULLP;
492 /* Fetch subscription detail in RAN Function DB */
493 CM_LLIST_FIRST_NODE(&ranFuncDb->subscriptionList, *ricSubscriptionNode);
494 while(*ricSubscriptionNode)
496 ricSubscriptionInfo = (RicSubscription *)((*ricSubscriptionNode)->node);
497 if(ricSubscriptionInfo && (ricSubscriptionInfo->requestId.requestorId == ricReqId.requestorId) &&
498 (ricSubscriptionInfo->requestId.instanceId == ricReqId.instanceId))
502 *ricSubscriptionNode = (*ricSubscriptionNode)->next;
503 ricSubscriptionInfo = NULLP;
506 if(!ricSubscriptionInfo)
508 DU_LOG("\nERROR --> E2AP : fetchSubsInfoFromRicReqId: Subscription not found for Requestor ID [%d] \
509 Instance ID [%d] in RAN Function ID [%d]", ricReqId.requestorId, ricReqId.instanceId, ranFuncDb->id);
512 return ricSubscriptionInfo;
515 /*******************************************************************
517 * @brief Fetch Action details
521 * Function : fetchActionInfoFromActionId
523 * Functionality: Fetch action details from RIC subscription DB
526 * @params[in] Action ID
527 * RIC Subscription DB
529 * @return Action Info DB
530 * NULL, in case of failure
532 * ****************************************************************/
533 ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo, CmLList ** actionNode)
535 ActionInfo *actionInfoDb = NULLP;
537 CM_LLIST_FIRST_NODE(&ricSubscriptionInfo->actionSequence, *actionNode);
540 actionInfoDb = (ActionInfo*)((*actionNode)->node);
541 if(actionInfoDb->actionId == actionId)
545 *actionNode= (*actionNode)->next;
547 if(actionInfoDb==NULLP)
549 DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
550 subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
551 ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
557 /******************************************************************
559 * @brief Search E2 node component with the help of interface type
564 * Function : fetchE2NodeComponentInfo
566 * Functionality: Search E2 node component
571 * Pointer to E2 component node to be searched
574 * ****************************************************************/
576 E2NodeComponent *fetchE2NodeComponentInfo(DuDb *duDb, InterfaceType interfaceType,CmLList **e2ComponentNode)
578 E2NodeComponent *e2NodeComponentInfo=NULLP;
580 if(duDb->e2NodeComponent.count)
582 CM_LLIST_FIRST_NODE(&duDb->e2NodeComponent, *e2ComponentNode);
583 while(*e2ComponentNode)
585 e2NodeComponentInfo = (E2NodeComponent*)((*e2ComponentNode)->node);
586 if((e2NodeComponentInfo->interfaceType == interfaceType))
591 *e2ComponentNode = (*e2ComponentNode)->next;
592 e2NodeComponentInfo = NULLP;
595 return e2NodeComponentInfo;
598 /*******************************************************************
600 * @brief update E2 node config list
604 * Function : updateE2NodeConfigList
607 * - update E2 node config list
611 * Configuration which need to update in Database
613 * @return ROK - success
616 * ****************************************************************/
617 uint8_t updateE2NodeConfigList(DuDb **duDb, uint8_t protocolId, E2NodeConfigItem *tmpCfg)
620 E2NodeComponent * e2NodeComponentInfo;
621 bool configFound= false;
625 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
627 /* Adding the new e2 node component in DB*/
628 RIC_ALLOC(e2NodeComponentInfo, sizeof(E2NodeComponent));
629 e2NodeComponentInfo->interfaceType = tmpCfg->componentInfo.interfaceType;
630 e2NodeComponentInfo->componentId =tmpCfg->componentInfo.componentId;
631 RIC_ALLOC(node, sizeof(CmLList));
634 node->node = (PTR) e2NodeComponentInfo;
635 cmLListAdd2Tail(&(*duDb)->e2NodeComponent, node);
640 DU_LOG("\nERROR --> E2AP : Memory allocation failed for e2NodeComponentList node");
641 RIC_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
646 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
648 /* searching for information in a database */
649 e2NodeComponentInfo = fetchE2NodeComponentInfo((*duDb),tmpCfg->componentInfo.interfaceType, &node);
650 if(!e2NodeComponentInfo)
652 DU_LOG("\nERROR --> E2AP : Failed to find the e2 component node");
655 /* If the node is present then update the value */
656 e2NodeComponentInfo->componentId =tmpCfg->componentInfo.componentId;
660 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
662 /* searching for information in a database */
663 e2NodeComponentInfo = fetchE2NodeComponentInfo((*duDb),tmpCfg->componentInfo.interfaceType, &node);
664 if(!e2NodeComponentInfo)
666 DU_LOG("\nERROR --> E2AP : Failed to find the e2 component node");
669 /* Delete the node from the list */
670 e2NodeComponentInfo->componentId = tmpCfg->componentInfo.componentId;
671 cmLListDelFrm(&(*duDb)->e2NodeComponent, node);
672 RIC_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
678 /* If the configuration update was successful, then mark the isSuccessful as
679 * true; otherwise, mark it as false. */
680 if(configFound == true)
681 tmpCfg->isSuccessful = true;
683 tmpCfg->isSuccessful = false;
688 /*******************************************************************
690 * @brief Handling the E2 node configuration depending on the add,
691 * update, or remove configuration type
695 * Function : handleE2NodeComponentAction
698 * - Handling the E2 node configuration depending on the add,
699 * update, or remove configuration type
702 * Pointer to e2NodeCfg which has info
704 * E2NodeConfigItem to be filled
706 * @return ROK - success
709 * ****************************************************************/
711 uint8_t handleE2NodeComponentAction(DuDb *duDb, PTR e2NodeCfg, uint8_t protocolId, E2NodeConfigItem *storeCfg)
713 uint8_t configFound = ROK;
714 E2NodeConfigItem tmpCfg;
715 E2nodeComponentID_t componentId;
716 E2nodeComponentInterfaceType_t interface;
717 E2nodeComponentConfigAddition_Item_t *addCfg=NULL;
718 E2nodeComponentConfigUpdate_Item_t *updateCfg=NULL;
719 E2nodeComponentConfigRemoval_Item_t *removeCfg=NULL;
721 /* fetching the interface and component id information from the e2NodeCfg */
722 memset(storeCfg, 0, sizeof(E2NodeConfigItem));
723 storeCfg->isSuccessful=false;
724 memset(&tmpCfg, 0, sizeof(E2NodeConfigItem));
728 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
730 addCfg = (E2nodeComponentConfigAddition_Item_t *)e2NodeCfg;
731 interface = addCfg->e2nodeComponentInterfaceType;
732 componentId = addCfg->e2nodeComponentID;
735 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
737 updateCfg = (E2nodeComponentConfigUpdate_Item_t *)e2NodeCfg;
738 interface = updateCfg->e2nodeComponentInterfaceType;
739 componentId = updateCfg->e2nodeComponentID;
742 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
744 removeCfg = (E2nodeComponentConfigRemoval_Item_t*)e2NodeCfg;
745 interface = removeCfg->e2nodeComponentInterfaceType;
746 componentId = removeCfg->e2nodeComponentID;
751 /* Storing the information in temporary structure */
752 tmpCfg.componentInfo.interfaceType = interface;
754 switch(componentId.present)
756 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
758 if(componentId.choice.e2nodeComponentInterfaceTypeF1)
760 tmpCfg.componentInfo.componentId = componentId.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
770 /* Updating the database configuration */
771 configFound = updateE2NodeConfigList(&duDb, protocolId, &tmpCfg);
773 memcpy(storeCfg, &tmpCfg,sizeof(E2NodeConfigItem));
778 /*******************************************************************
780 * @brief deallocate memory allocated in E2 Node Config Update Failure
784 * Function : FreeE2ConfigUpdateFail
786 * Functionality: deallocate memory allocated in E2 Node Config Update Failure
788 * @params[in] E2AP_PDU_t *e2apMsg
791 * ****************************************************************/
793 void FreeE2ConfigUpdateFail(E2AP_PDU_t *e2apMsg)
796 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
800 if(e2apMsg->choice.unsuccessfulOutcome)
802 e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
803 if(e2NodeCfgUpdFail->protocolIEs.list.array)
805 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
807 RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateFailure_IEs_t));
809 RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array, e2NodeCfgUpdFail->protocolIEs.list.size);
811 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
813 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
817 /*******************************************************************
819 * @brief Buld and send the E2 Node Config Update failure
823 * Function : BuildAndSendE2NodeConfigUpdateFailure
826 * - Buld and send the E2 Node Config Update failure
827 * @return ROK - success
830 * ****************************************************************/
832 uint8_t BuildAndSendE2NodeConfigUpdateFailure(uint32_t duId, uint8_t transId, uint8_t causeInfo, uint8_t causeReason)
834 E2AP_PDU_t *e2apMsg = NULL;
835 asn_enc_rval_t encRetVal;
837 uint8_t elementCnt=0;
838 bool memAllocFailed = false;
839 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdateFail=NULL;
841 DU_LOG("\nINFO --> E2AP : Building E2 Node Config Update failure\n");
844 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
847 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
850 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
851 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
852 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
854 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
858 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
859 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
860 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure;
861 e2NodeCfgUpdateFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
864 e2NodeCfgUpdateFail->protocolIEs.list.count = elementCnt;
865 e2NodeCfgUpdateFail->protocolIEs.list.size = elementCnt * sizeof(struct E2nodeConfigurationUpdateFailure_IEs *);
867 RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array, e2NodeCfgUpdateFail->protocolIEs.list.size);
868 if(e2NodeCfgUpdateFail->protocolIEs.list.array == NULLP)
870 DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure array failed");
874 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
876 RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx], sizeof(struct E2nodeConfigurationUpdateFailure_IEs));
877 if(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx] == NULLP)
879 DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure IEs failed");
880 memAllocFailed = true;
885 if(memAllocFailed == true)
892 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
893 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
894 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
895 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
898 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
899 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
900 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
901 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = causeInfo;
902 if(causeInfo == CauseE2_PR_e2Node)
903 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.e2Node = causeReason;
905 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.misc = causeReason;
908 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
909 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
910 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
911 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
913 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
914 memset(encBuf, 0, ENC_BUF_MAX_LEN);
916 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
918 /* Check encode results */
919 if(encRetVal.encoded == ENCODE_FAIL)
921 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node Config Update failure structure (at %s)\n",\
922 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
927 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node Config Update Failure\n");
928 for(int i=0; i< encBufSize; i++)
930 DU_LOG("%x",encBuf[i]);
934 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
936 DU_LOG("\nERROR --> E2AP : Sending E2 Node Config Update Failure failed");
942 FreeE2ConfigUpdateFail(e2apMsg);
946 /*******************************************************************
948 * @brief process the E2 node configuration update
952 * Function : ProcE2NodeConfigUpdate
954 * Functionality: Process E2 node configuration update
958 * Pointer to E2nodeConfigurationUpdate
961 ******************************************************************/
963 void ProcE2NodeConfigUpdate(uint32_t duId, E2nodeConfigurationUpdate_t *e2NodeConfigUpdate)
966 E2NodeConfigList tmpE2NodeList;
968 uint8_t ieIdx = 0, duIdx = 0, elementCnt=0, transId = 0;
969 E2nodeComponentConfigAddition_List_t *e2NodeAddList=NULL;
970 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe=NULL;
971 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
972 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList=NULLP;
973 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe=NULLP;
974 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULLP;
975 E2nodeComponentConfigRemoval_List_t *e2NodeRemoveList=NULL;
976 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItemIe=NULL;
977 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
979 SEARCH_DU_DB(duIdx, duId, duDb);
982 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
986 memset(&tmpE2NodeList, 0, sizeof(E2NodeConfigList));
987 if(!e2NodeConfigUpdate)
989 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate pointer is null");
992 if(!e2NodeConfigUpdate->protocolIEs.list.array)
994 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate array pointer is null");
998 elementCnt = e2NodeConfigUpdate->protocolIEs.list.count;
999 for(ieIdx=0; ieIdx < e2NodeConfigUpdate->protocolIEs.list.count; ieIdx++)
1001 if(!e2NodeConfigUpdate->protocolIEs.list.array[ieIdx])
1003 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate array idx %d pointer is null",arrIdx);
1007 switch(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->id)
1009 case ProtocolIE_IDE2_id_TransactionID:
1011 transId = e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
1012 if(transId < 0 || transId > 255)
1014 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
1020 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1022 e2NodeAddList =&e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigAddition_List;
1023 if(e2NodeAddList->list.array)
1025 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
1027 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
1028 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
1029 /* Storing the E2 node information in DB */
1030 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeAddItem, ProtocolIE_IDE2_id_E2nodeComponentConfigAddition,\
1031 &tmpE2NodeList.addedE2Node[tmpE2NodeList.addedE2NodeCount++]) != ROK)
1033 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1040 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
1042 e2NodeUpdateList =&e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigUpdate_List;
1043 if(e2NodeUpdateList->list.array)
1045 for(arrIdx = 0; arrIdx< e2NodeUpdateList->list.count; arrIdx++)
1047 e2NodeUpdateItemIe = (E2nodeComponentConfigUpdate_ItemIEs_t*) e2NodeUpdateList->list.array[arrIdx];
1048 e2NodeUpdateItem = &e2NodeUpdateItemIe->value.choice.E2nodeComponentConfigUpdate_Item;
1050 /* Updating the E2 node information in DB */
1051 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeUpdateItem, ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate,\
1052 &tmpE2NodeList.updatedE2Node[tmpE2NodeList.updatedE2NodeCount++]) != ROK)
1054 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1061 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
1063 e2NodeRemoveList = &e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigRemoval_List;
1064 if(e2NodeRemoveList->list.array)
1066 for(arrIdx = 0; arrIdx< e2NodeRemoveList->list.count; arrIdx++)
1068 e2NodeRemovalItemIe = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemoveList->list.array[arrIdx];
1069 e2NodeRemovalItem = &e2NodeRemovalItemIe->value.choice.E2nodeComponentConfigRemoval_Item;
1071 /* Removing the E2 node information in DB */
1072 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeRemovalItem, ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval,\
1073 &tmpE2NodeList.removedE2Node[tmpE2NodeList.removedE2NodeCount++]) != ROK)
1075 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1088 /* If all of the IEs are processed successfully, we will send an e2 node
1089 * config update ack message.
1090 * else we will be sendinf e2 node config update failure */
1091 if(elementCnt == ieIdx)
1093 if(BuildAndSendE2NodeConfigUpdateAck(duDb, transId, &tmpE2NodeList) !=ROK)
1095 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 node config ack");
1101 if(BuildAndSendE2NodeConfigUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
1103 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 node config Failure");
1108 /*******************************************************************
1110 * @brief Builds Global RIC Id Params
1114 * Function : BuildGlobalRicId
1116 * Functionality: Building the Plmn and ric id
1118 * @params[in] GlobalRIC_ID_t *ricId
1119 * @return ROK - success
1122 * ****************************************************************/
1124 uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId)
1127 uint8_t byteSize = 3;
1131 ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
1132 RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
1133 buildPlmnId(ricCb.ricCfgParams.plmn , ricId->pLMN_Identity.buf);
1135 ricId->ric_ID.size = byteSize * sizeof(uint8_t);
1136 RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
1137 fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
1142 /*******************************************************************
1144 * @brief deallocate the memory allocated in E2SetupResponse
1148 * Function : FreeE2SetupRsp
1150 * Functionality: deallocate the memory allocated in E2SetupResponse
1152 * @params[in] E2AP_PDU_t *e2apMsg
1155 * ****************************************************************/
1156 void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
1158 uint8_t arrIdx = 0, e2NodeConfigIdx=0, ranFuncIdx=0;
1159 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
1160 E2setupResponse_t *e2SetupRsp=NULL;
1161 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULL;
1162 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULL;
1163 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULL;
1167 if(e2apMsg->choice.successfulOutcome)
1169 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
1170 if(e2SetupRsp->protocolIEs.list.array)
1172 for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
1174 switch(e2SetupRsp->protocolIEs.list.array[arrIdx]->id)
1176 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
1178 ranFuncAcceptedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
1179 if(ranFuncAcceptedList->list.array)
1181 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
1183 if(ranFuncAcceptedList->list.array[ranFuncIdx])
1185 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1188 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
1192 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1194 e2NodeConfigAdditionAckList =&e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
1195 if(e2NodeConfigAdditionAckList->list.count)
1197 for(e2NodeConfigIdx=0; e2NodeConfigIdx<e2NodeConfigAdditionAckList->list.count; e2NodeConfigIdx++)
1199 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2NodeConfigIdx];
1200 if(e2NodeAddAckItemIe)
1202 f1InterfaceInfo = e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
1205 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
1206 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
1208 RIC_FREE(e2NodeAddAckItemIe, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
1211 RIC_FREE(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
1216 RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
1218 RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
1220 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1222 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1226 /*******************************************************************
1228 * @brief fill e2 node configuration for ack msg
1232 * Function : fillE2NodeConfigAck
1235 * - fill e2 node configuration for ack msg
1238 * Pointer to e2NodeCfg to be filled
1240 * E2 Node Component information
1241 * Is successful or failure response
1242 * @return ROK - success
1245 * ****************************************************************/
1247 uint8_t fillE2NodeConfigAck(PTR e2NodeCfg, uint8_t procedureCode, E2NodeComponent *componentInfo, bool isSuccessful)
1249 E2nodeComponentID_t *e2nodeComponentID=NULLP;
1250 E2nodeComponentInterfaceType_t *e2nodeComponentInterfaceType=NULLP;
1251 E2nodeComponentConfigurationAck_t *e2nodeComponentConfigurationAck=NULLP;
1252 E2nodeComponentConfigRemovalAck_Item_t *removalAckItem=NULLP;
1253 E2nodeComponentConfigUpdateAck_Item_t *updateAckItem=NULLP;
1254 E2nodeComponentConfigAdditionAck_Item_t *additionAckItem=NULLP;
1256 /* filling the interface type, component id, configuration ack based on the
1257 * e2 node configuration add, update, delete type */
1258 switch(procedureCode)
1260 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1262 additionAckItem = (E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg;
1263 e2nodeComponentInterfaceType = &((E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg)->e2nodeComponentInterfaceType;
1264 e2nodeComponentID = &additionAckItem->e2nodeComponentID;
1265 e2nodeComponentConfigurationAck = &additionAckItem->e2nodeComponentConfigurationAck;
1268 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
1270 updateAckItem = (E2nodeComponentConfigUpdateAck_Item_t*) e2NodeCfg;
1271 e2nodeComponentInterfaceType = &updateAckItem->e2nodeComponentInterfaceType;
1272 e2nodeComponentID = &updateAckItem->e2nodeComponentID;
1273 e2nodeComponentConfigurationAck = &updateAckItem->e2nodeComponentConfigurationAck;
1276 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
1278 removalAckItem= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
1279 e2nodeComponentInterfaceType = &removalAckItem->e2nodeComponentInterfaceType;
1280 e2nodeComponentID = &removalAckItem->e2nodeComponentID;
1281 e2nodeComponentConfigurationAck = &removalAckItem->e2nodeComponentConfigurationAck;
1286 /* >E2 Node Component interface type */
1287 if(componentInfo->interfaceType>=NG && componentInfo->interfaceType<=X2)
1289 *e2nodeComponentInterfaceType = componentInfo->interfaceType;
1293 DU_LOG("\nERROR --> E2AP: Received an invalid interface value %d",componentInfo->interfaceType);
1297 if(*e2nodeComponentInterfaceType == E2nodeComponentInterfaceType_f1)
1299 /* >E2 Node Component ID */
1300 e2nodeComponentID->present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
1301 RIC_ALLOC(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
1302 if(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
1304 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1307 e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
1308 RIC_ALLOC(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1310 if(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
1312 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1315 e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = componentInfo->componentId;
1320 /* >E2 Node Component Configuration Acknowledge*/
1321 e2nodeComponentConfigurationAck->updateOutcome = E2nodeComponentConfigurationAck__updateOutcome_success;
1325 /* >E2 Node Component Configuration Acknowledge*/
1326 e2nodeComponentConfigurationAck->updateOutcome = E2nodeComponentConfigurationAck__updateOutcome_failure;
1327 RIC_ALLOC(e2nodeComponentConfigurationAck->failureCauseE2, sizeof(struct CauseE2));
1328 if(e2nodeComponentConfigurationAck->failureCauseE2)
1330 fillE2FailureCause(e2nodeComponentConfigurationAck->failureCauseE2, CauseE2_PR_e2Node, CauseE2node_e2node_component_unknown);
1334 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1341 /*******************************************************************
1343 * @brief Build E2node Component config addition ack list
1347 * Function : BuildE2nodeComponentConfigAdditionAck
1349 * Functionality: Build E2node Component config addition ack list
1352 * E2nodeComponentConfigAdditionAck_List to be filled
1353 * Count of e2 node to be added
1354 * list of e2 node cfg to be added
1356 * @return ROK - success
1358 * ****************************************************************/
1360 uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, \
1361 uint16_t addedE2NodeCount, E2NodeConfigItem *addedE2Node)
1363 E2NodeComponent *e2NodeComponentInfo=NULLP;
1364 CmLList *node=NULLP;
1365 uint16_t arrIdx = 0;
1366 E2nodeComponentConfigAdditionAck_Item_t *e2NodeAddAckItem=NULLP;
1367 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULLP;
1369 e2NodeConfigAdditionAckList->list.count = addedE2NodeCount;
1371 e2NodeConfigAdditionAckList->list.size = e2NodeConfigAdditionAckList->list.count * sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t*);
1372 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
1373 if(e2NodeConfigAdditionAckList->list.array == NULLP)
1375 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
1379 for(arrIdx = 0; arrIdx< e2NodeConfigAdditionAckList->list.count; arrIdx++)
1381 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
1382 if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
1384 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
1387 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[arrIdx];
1388 e2NodeAddAckItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
1389 e2NodeAddAckItemIe->criticality = CriticalityE2_reject;
1390 e2NodeAddAckItemIe->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_E2nodeComponentConfigAdditionAck_Item;
1391 e2NodeAddAckItem = &e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item;
1393 /* Filling the e2 node config addition ack item */
1394 fillE2NodeConfigAck((PTR)&e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck,\
1395 &addedE2Node[arrIdx].componentInfo, addedE2Node[arrIdx].isSuccessful);
1400 /*******************************************************************
1402 * @brief Build RAN function accepted list
1406 * Function : BuildRanFunctionAcceptedList
1408 * Functionality: Build RAN function accepted list
1409 * ->For ProcedureCodeE2_id_E2setup or ProcedureCodeE2_id_RICserviceQuery
1410 * we add all the RAN Function list which is present in RIC database.
1411 * ->For any other procedures, we just fill the RAN functions whose ID
1412 * is present in the recvList
1416 * Count of ran functions to be accepted in the list
1417 * Received list of RAN functions
1421 * @return ROK - success
1423 * ****************************************************************/
1425 uint8_t BuildRanFunctionAcceptedList(DuDb *duDb, uint8_t count, RanFunction *ranFunAcceptedList, RANfunctionsID_List_t *ranFuncAcceptedList, uint8_t procedureCode)
1427 uint16_t ranFuncIdx = 0;
1428 RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL;
1430 /* For ProcedureCodeE2_id_E2setup and ProcedureCodeE2_id_RICserviceQuery,
1431 * the number of RAN function list items is equal to the number of
1432 * ran function entries stored in the database.
1433 * For any other procedure, the RAN function list count is equal
1434 * to the count of ran functions obtained from the function's caller */
1436 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
1437 ranFuncAcceptedList->list.count = duDb->numOfRanFunction;
1439 ranFuncAcceptedList->list.count = count;
1441 ranFuncAcceptedList->list.size = ranFuncAcceptedList->list.count*sizeof(RANfunctionID_ItemIEs_t*);
1442 RIC_ALLOC(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
1443 if(ranFuncAcceptedList->list.array)
1445 for(ranFuncIdx = 0; ranFuncIdx< ranFuncAcceptedList->list.count; ranFuncIdx++)
1447 RIC_ALLOC(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1448 if(ranFuncAcceptedList->list.array[ranFuncIdx] == NULLP)
1450 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array item");
1453 ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[ranFuncIdx];
1454 ranFuncAcceptedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
1455 ranFuncAcceptedItemIe->criticality= CriticalityE2_ignore;
1456 ranFuncAcceptedItemIe->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item;
1457 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
1459 /* filling the RAN function information with the help of DuDb */
1460 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = duDb->ranFunction[ranFuncIdx].id;
1461 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= duDb->ranFunction[ranFuncIdx].revisionCounter;
1465 /* filling the the RAN function information with the help received list of RAN functions */
1466 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = ranFunAcceptedList[ranFuncIdx].id;
1467 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= ranFunAcceptedList[ranFuncIdx].revisionCounter;
1473 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array");
1479 /*******************************************************************
1481 * @brief Builds and sends the E2SetupResponse
1485 * Function : BuildAndSendE2SetupRsp
1487 * Functionality: Builds and sends the E2SetupResponse
1492 * List of E2node cofniguration which needs to be send
1494 * @return ROK - success
1497 * ****************************************************************/
1499 uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId, E2NodeConfigList e2NodeList)
1501 E2AP_PDU_t *e2apMsg = NULL;
1502 E2setupResponse_t *e2SetupRsp;
1503 asn_enc_rval_t encRetVal;
1506 bool memAllocFailed = false;
1508 DU_LOG("\nINFO --> E2AP : Building E2 Setup Response\n");
1511 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1512 if(e2apMsg == NULLP)
1514 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1517 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1518 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1519 if(e2apMsg->choice.successfulOutcome == NULLP)
1521 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1525 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
1526 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1527 e2apMsg->choice.successfulOutcome->value.present = \
1528 SuccessfulOutcomeE2__value_PR_E2setupResponse;
1529 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
1532 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
1533 if(duDb->numOfRanFunction)
1536 e2SetupRsp->protocolIEs.list.count = elementCnt;
1537 e2SetupRsp->protocolIEs.list.size = elementCnt * sizeof(E2setupResponseIEs_t*);
1539 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
1540 if(e2SetupRsp->protocolIEs.list.array == NULLP)
1542 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
1546 for(idx=0; idx<elementCnt; idx++)
1548 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], sizeof(E2setupResponseIEs_t));
1549 if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
1551 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
1552 memAllocFailed = true;
1557 if(memAllocFailed == true)
1559 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
1564 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_TransactionID;
1565 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1566 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_TransactionID;
1567 e2SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID = transId;
1571 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID;
1572 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1573 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_GlobalRIC_ID;
1575 if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK)
1577 DU_LOG("\nERROR --> E2AP : Failed to build Global Ric Id");
1581 if(duDb->numOfRanFunction)
1583 /* Accepted RAN function Id */
1585 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
1586 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1587 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List;
1588 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_E2setup)!=ROK)
1590 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
1595 /* E2 Node Component Configuration Addition Acknowledge List*/
1597 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
1598 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1599 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
1600 E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List;
1601 if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->\
1602 value.choice.E2nodeComponentConfigAdditionAck_List, e2NodeList.addedE2NodeCount, e2NodeList.addedE2Node) != ROK)
1604 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
1608 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1609 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1611 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1613 /* Check encode results */
1614 if(encRetVal.encoded == ENCODE_FAIL)
1616 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
1617 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1622 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
1623 for(int i=0; i< encBufSize; i++)
1625 DU_LOG("%x",encBuf[i]);
1629 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
1631 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
1637 FreeE2SetupRsp(e2apMsg);
1638 BuildAndSendRicSubscriptionReq(duDb);
1642 /*******************************************************************
1644 * @brief Free RIC Subscription Details
1648 * Function : FreeRicSubsDetails
1650 * Functionality: Free the RIC Subscription Details
1652 * @params[in] RICsubscriptionDetails_t *subsDetails
1655 * ****************************************************************/
1656 void FreeRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
1658 uint8_t elementIdx = 0;
1659 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
1661 RIC_FREE(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size);
1663 if(subsDetails->ricAction_ToBeSetup_List.list.array)
1665 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
1667 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
1669 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
1670 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
1672 RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf, \
1673 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size);
1674 RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
1676 RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t))
1679 RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
1683 /*******************************************************************
1685 * @brief Free RIC Subscription Request
1689 * Function : FreeRicSubscriptionReq
1691 * Functionality : Free RIC Subscription Request
1693 * @return ROK - success
1696 ******************************************************************/
1697 void FreeRicSubscriptionReq(E2AP_PDU_t *e2apRicMsg)
1700 RICsubscriptionRequest_t *ricSubscriptionReq;
1704 if(e2apRicMsg->choice.initiatingMessage)
1706 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
1707 if(ricSubscriptionReq->protocolIEs.list.array)
1709 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
1711 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
1713 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
1715 FreeRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails));
1719 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
1721 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
1723 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1725 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
1729 /*******************************************************************
1731 * @brief Builds Ric Request Id
1735 * Function : BuildNewRicRequestId
1737 * Functionality: Assign new Ric Request ID
1739 * @params[in] RIC request ID to be sent
1740 * RIC request ID stored in DB
1741 * @return ROK - success
1744 * ****************************************************************/
1746 uint8_t BuildNewRicRequestId(RICrequestID_t *ricReqId, RicRequestId *reqIdDb)
1748 static uint16_t requestorId = 0;
1749 static uint16_t instanceId = 0;
1751 if(ricReqId != NULLP)
1753 ricReqId->ricRequestorID = ++requestorId;
1754 ricReqId->ricInstanceID = ++instanceId;
1756 reqIdDb->requestorId = ricReqId->ricRequestorID;
1757 reqIdDb->instanceId = ricReqId->ricInstanceID;
1762 /*******************************************************************
1764 * @brief Free RIC Action Definition
1768 * Function : FreeRicActionDefinition
1770 * Functionality: Free RIC Action Definition
1772 * @params[in] E2SM-KPM Action definition
1775 * ****************************************************************/
1776 void FreeRicActionDefinition(E2SM_KPM_ActionDefinition_t actionDef)
1778 uint8_t elementIdx = 0;
1779 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
1780 MeasurementInfoItem_t *measItem = NULLP;
1782 switch(actionDef.actionDefinition_formats.present)
1784 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
1786 if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1)
1788 actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
1789 if(actionFormat1->measInfoList.list.array)
1791 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
1793 if(actionFormat1->measInfoList.list.array[elementIdx])
1795 measItem = actionFormat1->measInfoList.list.array[elementIdx];
1796 switch(measItem->measType.present)
1798 case MeasurementType_PR_NOTHING:
1799 case MeasurementType_PR_measID:
1801 case MeasurementType_PR_measName:
1803 RIC_FREE(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size)
1807 RIC_FREE(measItem, sizeof(MeasurementInfoItem_t));
1810 RIC_FREE(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
1812 RIC_FREE(actionFormat1, sizeof(E2SM_KPM_ActionDefinition_Format1_t));
1817 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
1818 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
1819 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
1820 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
1821 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_NOTHING:
1826 /*******************************************************************
1828 * @brief Fill RIC Action Definition
1832 * Function : fillRicActionDef
1834 * Functionality: Fill RIC Action Definition
1836 * @params[in] RIC Action definition
1840 * ****************************************************************/
1841 uint8_t fillRicActionDef(RICactionDefinition_t *ricActionDef, uint8_t ricActionId, ConfigType configType)
1843 uint8_t ret = RFAILED;
1844 asn_enc_rval_t encRetVal;
1845 uint8_t elementCnt = 0, elementIdx = 0;
1846 char *measurementTypeName[] = {"RRU.PrbTotDl", "RRU.PrbTotUl"};
1847 E2SM_KPM_ActionDefinition_t actionDef;
1848 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
1849 MeasurementInfoItem_t *measItem = NULLP;
1853 /* Fill E2SM-KPM Action Definition Format 1 */
1855 /* RIC Stype Type */
1856 actionDef.ric_Style_Type = RIC_STYLE_TYPE;
1858 /* RIC Action Definition Format 1 */
1859 actionDef.actionDefinition_formats.present = \
1860 E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1;
1862 RIC_ALLOC(actionDef.actionDefinition_formats.choice.actionDefinition_Format1, \
1863 sizeof(E2SM_KPM_ActionDefinition_Format1_t));
1864 if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1 == NULLP)
1866 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1869 actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
1871 /* Measurement Info List */
1873 actionFormat1->measInfoList.list.count = elementCnt;
1874 actionFormat1->measInfoList.list.size = elementCnt * sizeof(MeasurementInfoItem_t *);
1875 RIC_ALLOC(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
1876 if(actionFormat1->measInfoList.list.array == NULL)
1878 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1882 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
1884 RIC_ALLOC(actionFormat1->measInfoList.list.array[elementIdx], sizeof(MeasurementInfoItem_t));
1885 if(actionFormat1->measInfoList.list.array[elementIdx] == NULLP)
1887 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1891 measItem = actionFormat1->measInfoList.list.array[elementIdx];
1892 measItem->measType.present = MeasurementType_PR_measName;
1894 measItem->measType.choice.measName.size = strlen(measurementTypeName[elementIdx]);
1895 RIC_ALLOC(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size);
1896 if(measItem->measType.choice.measName.buf == NULLP)
1898 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1901 memcpy(measItem->measType.choice.measName.buf, measurementTypeName[elementIdx], measItem->measType.choice.measName.size);
1903 if(elementIdx < elementCnt)
1906 /* Granularity Period */
1907 actionFormat1->granulPeriod = RIC_ACTION_GRANULARITY_PERIOD(configType, ricActionId); /* In ms */
1909 /* Prints the Msg formed */
1910 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, &actionDef);
1912 /* Encode E2SM-KPM RIC Action Definition */
1913 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1915 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_ActionDefinition, 0, &actionDef, PrepFinalEncBuf, encBuf);
1916 if(encRetVal.encoded == ENCODE_FAIL)
1918 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM action definition structure (at %s)\n",\
1919 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1923 /* Copty encoded E2SM-KPM RIC action definition to E2AP octet string buffer */
1924 ricActionDef->size = encBufSize;
1925 RIC_ALLOC(ricActionDef->buf, encBufSize);
1926 if(ricActionDef->buf == NULLP)
1928 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1931 memcpy(ricActionDef->buf, encBuf, encBufSize);
1937 FreeRicActionDefinition(actionDef);
1941 /*******************************************************************
1943 * @brief Fills RIC Action To Be Setup Item
1947 * Function : fillActionToBeSetup
1949 * Functionality: Fill the RIC Action To Be Setup Ite,
1950 * RIC subscription DB
1952 * @params[in] RICaction_ToBeSetup_ItemIEs_t *items
1953 * @return ROK - success
1956 * ****************************************************************/
1957 uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscription *ricSubsDb)
1959 static uint8_t ricActionId = 0;
1960 CmLList *actionNode=NULLP;
1961 if(actionItem == NULLP)
1963 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1969 actionItem->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item;
1970 actionItem->criticality = CriticalityE2_ignore;
1971 actionItem->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
1974 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId;
1975 actionNode = addRicSubsAction(ricActionId, &ricSubsDb->actionSequence);
1978 /* RIC Action Type */
1979 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report;
1981 /* RIC Action Definition */
1982 RIC_ALLOC(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
1983 if(!actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
1985 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1988 if(fillRicActionDef(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, ricActionId, CONFIG_ADD) != ROK)
1990 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1999 deleteActionSequence(actionNode);
2004 /*******************************************************************
2006 * @brief Free Event Trigger Definition
2010 * Function : FreeEventTriggerDef
2012 * Functionality: Free Event Trigger Definition
2014 * @params[in] E2SM-KPM Event Trigger Definition
2017 * ****************************************************************/
2018 void FreeEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
2022 switch(eventTiggerDef->eventDefinition_formats.present)
2024 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
2026 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
2027 RIC_FREE(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1, \
2028 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
2034 /*******************************************************************
2036 * @brief Fill Event Trigger Definition
2040 * Function : fillEventTriggerDef
2042 * Functionality: Fill Event Trigger Definition
2044 * @params[in] RIC Event Trigger Definition
2048 * ****************************************************************/
2049 uint8_t fillEventTriggerDef(RICeventTriggerDefinition_t *ricEventTriggerDef)
2051 uint8_t ret = RFAILED;
2052 asn_enc_rval_t encRetVal;
2053 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef;
2057 /* Fill E2SM-KPM Event Trigger Definition Format 1 */
2058 eventTiggerDef.eventDefinition_formats.present = \
2059 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1;
2061 RIC_ALLOC(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1, \
2062 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
2063 if(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1 == NULLP)
2065 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2069 eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod = 1000; /* In ms */
2071 /* Prints the Msg formed */
2072 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, &eventTiggerDef);
2074 /* Encode E2SM-KPM Event Trigger Definition */
2075 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2077 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_EventTriggerDefinition, 0, &eventTiggerDef, PrepFinalEncBuf, encBuf);
2078 if(encRetVal.encoded == ENCODE_FAIL)
2080 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM event trigger definition structure (at %s)\n",\
2081 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2085 /* Copy encoded E2SM-KPM event trigger definition to E2AP octet string buffer */
2086 ricEventTriggerDef->size = encBufSize;
2087 RIC_ALLOC(ricEventTriggerDef->buf, encBufSize);
2088 if(ricEventTriggerDef->buf == NULLP)
2090 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2093 memcpy(ricEventTriggerDef->buf, encBuf, encBufSize);
2099 FreeEventTriggerDef(&eventTiggerDef);
2103 /*******************************************************************
2105 * @brief builds RIC Subscription Details
2109 * Function : BuildsRicSubsDetails
2111 * Functionality: Builds the RIC Subscription Details
2113 * @params[in] RIC Subscription details to be filled
2114 * RIC subscriotion DB
2115 * @return ROK - success
2118 * ****************************************************************/
2120 uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails, RicSubscription *ricSubsInfo)
2122 uint8_t elementCnt = 0;
2123 uint8_t elementIdx = 0;
2125 if(subsDetails == NULLP)
2127 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2133 /* RIC Event Trigger Definition */
2134 if(fillEventTriggerDef(&subsDetails->ricEventTriggerDefinition) != ROK)
2136 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2140 /* RIC Actions To Be Setup List */
2142 subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
2143 subsDetails->ricAction_ToBeSetup_List.list.size = elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t *);
2144 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
2145 if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
2147 DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
2151 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
2153 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t));
2154 if(!subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
2156 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2160 if(elementIdx < elementCnt)
2165 if(fillActionToBeSetup((RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], \
2166 ricSubsInfo) != ROK)
2168 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2177 /*******************************************************************
2179 * @brief Builds and Send the RicSubscriptionReq
2183 * Function : BuildAndSendRicSubscriptionReq
2185 * Functionality:Fills the RicSubscriptionReq
2187 * @return ROK - success
2190 ******************************************************************/
2191 uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb)
2193 uint8_t ret = RFAILED;
2194 uint8_t elementCnt = 0;
2196 uint8_t actionIdx = 0;
2197 asn_enc_rval_t encRetVal; /* Encoder return value */
2198 E2AP_PDU_t *e2apRicMsg = NULL;
2199 RICsubscriptionRequest_t *ricSubscriptionReq;
2200 RanFunction *ranFuncDb = &duDb->ranFunction[0];
2201 CmLList *ricSubsNode = NULLP;
2202 RicSubscription *ricSubsInfo = NULLP;
2204 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
2206 /* Allocate memory to store RIC subscription info in RIC DB */
2207 RIC_ALLOC(ricSubsInfo, sizeof(RicSubscription));
2210 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2216 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
2217 if(e2apRicMsg == NULLP)
2219 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2223 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
2224 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2225 if(e2apRicMsg->choice.initiatingMessage == NULLP)
2227 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2230 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
2231 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2232 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
2234 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
2237 ricSubscriptionReq->protocolIEs.list.count = elementCnt;
2238 ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
2240 /* Initialize the subscription members */
2241 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
2242 if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
2244 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2248 for(idx=0; idx<elementCnt; idx++)
2250 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
2251 if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
2253 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2257 if(idx < elementCnt)
2260 /* Filling RIC Request Id */
2262 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
2263 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2264 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
2265 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
2266 if(BuildNewRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID, \
2267 &ricSubsInfo->requestId) != ROK)
2269 DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
2274 /* Filling RAN Function Id */
2276 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
2277 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2278 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
2279 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
2280 ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ranFuncDb->id;
2281 ricSubsInfo->ranFuncId = ranFuncDb->id;
2283 /* Filling RIC Subscription Details */
2285 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
2286 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2287 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
2288 RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
2289 if(BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails),\
2290 ricSubsInfo) != ROK)
2292 DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
2296 /* Prints the Msg formed */
2297 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
2299 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2301 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
2302 if(encRetVal.encoded == ENCODE_FAIL)
2304 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
2305 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2310 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
2311 for(int i=0; i< encBufSize; i++)
2313 DU_LOG("%x",encBuf[i]);
2318 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
2320 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
2324 /* Add RIC Subscription Info to RAN Function's RIC Subscription List */
2325 RIC_ALLOC(ricSubsNode , sizeof(CmLList));
2328 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2331 ricSubsNode->node = (PTR)ricSubsInfo;
2332 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubsNode);
2340 RIC_FREE(ricSubsInfo, sizeof(RicSubscription));
2341 RIC_FREE(ricSubsNode , sizeof(CmLList));
2344 FreeRicSubscriptionReq(e2apRicMsg);
2348 /*******************************************************************
2350 * @brief Process RicSubscriptionResponse
2354 * Function : ProcRicSubscriptionRsp
2356 * Functionality: Processes RicSubscriptionRsp
2358 * @return ROK - void
2360 ******************************************************************/
2362 void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp)
2364 uint8_t duIdx = 0, ieIdx = 0, notAdmitIdx = 0;
2365 uint8_t ranFuncId = 0, actionId = 0;
2367 bool ricReqIdDecoded = false;
2368 RicRequestId ricReqId;
2369 RanFunction *ranFuncDb = NULLP;
2370 RicSubscription *ricSubs = NULLP;
2371 CmLList *ricSubsNode = NULLP;
2372 CmLList *actionNode = NULLP;
2373 ActionInfo *action = NULLP;
2374 RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP;
2375 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
2377 DU_LOG("\nINFO --> E2AP : RIC Subscription Response received");
2380 SEARCH_DU_DB(duIdx, duId, duDb);
2383 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
2387 memset(&ricReqId, 0, sizeof(RicRequestId));
2388 if(ricSubscriptionRsp)
2390 if(ricSubscriptionRsp->protocolIEs.list.array)
2392 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
2394 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx])
2396 ricSubsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2397 switch(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]->id)
2399 case ProtocolIE_IDE2_id_RICrequestID:
2401 ricReqId.requestorId = ricSubsRspIe->value.choice.RICrequestID.ricRequestorID;
2402 ricReqId.instanceId = ricSubsRspIe->value.choice.RICrequestID.ricInstanceID;
2403 ricReqIdDecoded = true;
2406 case ProtocolIE_IDE2_id_RANfunctionID:
2408 ranFuncId = ricSubsRspIe->value.choice.RANfunctionID;
2409 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
2412 DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId);
2417 case ProtocolIE_IDE2_id_RICactions_Admitted:
2421 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
2423 if(!(ranFuncDb && ricReqIdDecoded))
2426 notAdmitList = &ricSubsRspIe->value.choice.RICaction_NotAdmitted_List;
2427 for(notAdmitIdx = 0; notAdmitIdx < notAdmitList->list.count; notAdmitIdx++)
2430 actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\
2431 value.choice.RICaction_NotAdmitted_Item.ricActionID;
2433 /* Remove action from RAN Function's subscription list */
2434 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
2437 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
2440 deleteActionSequence(action);
2453 /*******************************************************************
2455 * @brief deallocate the memory allocated in E2SetupFailure
2459 * Function : FreeE2SetupFailure
2461 * Functionality: deallocate the memory allocated in E2SetupFailure
2463 * @params[in] E2AP_PDU_t *e2apMsg
2466 * ****************************************************************/
2467 void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg)
2470 E2setupFailure_t *e2SetupFail;
2474 if(e2apMsg->choice.unsuccessfulOutcome)
2476 e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
2477 if(e2SetupFail->protocolIEs.list.array)
2479 for(arrIdx=0; arrIdx<e2SetupFail->protocolIEs.list.count; arrIdx++)
2481 RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t));
2483 RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size);
2485 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
2487 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2491 /*******************************************************************
2493 * @brief Buld and send the E2 Setup failure
2497 * Function : BuildAndSendE2SetupFailure
2500 * - Buld and send the E2 Setup failure
2501 * @return ROK - success
2504 * ****************************************************************/
2506 uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId)
2508 uint8_t ret = RFAILED;
2509 E2AP_PDU_t *e2apMsg = NULL;
2510 E2setupFailure_t *e2SetupFailure;
2511 asn_enc_rval_t encRetVal;
2514 bool memAllocFailed = false;
2516 DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
2519 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2520 if(e2apMsg == NULLP)
2522 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2525 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
2526 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
2527 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
2529 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2533 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
2534 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
2535 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure;
2536 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
2539 e2SetupFailure->protocolIEs.list.count = elementCnt;
2540 e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *);
2542 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
2543 if(e2SetupFailure->protocolIEs.list.array == NULLP)
2545 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2549 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2551 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
2552 if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
2554 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2555 memAllocFailed = true;
2560 if(memAllocFailed == true)
2562 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2568 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2569 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2570 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
2571 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2574 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
2575 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2576 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
2577 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol;
2578 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified;
2581 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
2582 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
2583 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
2584 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
2586 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2587 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2589 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2591 /* Check encode results */
2592 if(encRetVal.encoded == ENCODE_FAIL)
2594 DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
2595 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2600 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
2601 for(int i=0; i< encBufSize; i++)
2603 DU_LOG("%x",encBuf[i]);
2607 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2609 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
2617 FreeE2SetupFailure(e2apMsg);
2621 /*******************************************************************
2623 * @brief process the e2setup request
2627 * Function : ProcE2SetupReq
2629 * Functionality: process the e2setup request
2633 ******************************************************************/
2635 void ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
2637 uint8_t arrIdx = 0, duIdx = 0, transId =0;
2638 uint16_t ranFuncIdx=0, e2NodeAddListIdx =0;
2639 E2NodeConfigList tmpE2NodeList;
2641 bool ieProcessingFailed = false;
2642 E2nodeComponentConfigAddition_List_t *e2NodeAddList=NULLP;
2643 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem=NULLP;
2644 RANfunction_ItemIEs_t *ranFuncItemIe=NULLP;
2645 RANfunction_Item_t *ranFunItem=NULLP;
2646 RANfunctions_List_t *ranFunctionsList=NULLP;
2648 memset(&tmpE2NodeList, 0, sizeof(E2NodeConfigList));
2651 DU_LOG("\nERROR --> E2AP : e2SetupReq pointer is null");
2654 if(!e2SetupReq->protocolIEs.list.array)
2656 DU_LOG("\nERROR --> E2AP : e2SetupReq array pointer is null");
2660 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
2662 if(e2SetupReq->protocolIEs.list.array[arrIdx])
2664 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
2666 case ProtocolIE_IDE2_id_TransactionID:
2668 transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2671 case ProtocolIE_IDE2_id_GlobalE2node_ID:
2673 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID)
2675 *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0];
2677 SEARCH_DU_DB(duIdx, *duId, duDb);
2680 duDb = &ricCb.duInfo[ricCb.numDu];
2683 memset(duDb, 0, sizeof(DuDb));
2688 case ProtocolIE_IDE2_id_RANfunctionsAdded:
2690 ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2692 if(ranFunctionsList->list.array)
2694 for(ranFuncIdx=0;ranFuncIdx<ranFunctionsList->list.count; ranFuncIdx++)
2696 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
2697 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2698 duDb->ranFunction[ranFunItem->ranFunctionID-1].id = ranFunItem->ranFunctionID;
2699 duDb->ranFunction[ranFunItem->ranFunctionID-1].revisionCounter = ranFunItem->ranFunctionRevision;
2700 cmLListInit(&duDb->ranFunction[ranFunItem->ranFunctionID-1].subscriptionList);
2701 duDb->numOfRanFunction++;
2706 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
2708 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
2709 if(e2NodeAddList->list.array)
2711 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
2713 if(e2NodeAddList->list.array[e2NodeAddListIdx])
2715 /* Storing the E2 node information in DB */
2716 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *)e2NodeAddList->list.array[e2NodeAddListIdx];
2717 if(handleE2NodeComponentAction(duDb, (PTR)&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item,\
2718 ProtocolIE_IDE2_id_E2nodeComponentConfigAddition, &tmpE2NodeList.addedE2Node[tmpE2NodeList.addedE2NodeCount++]) != ROK)
2720 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",e2NodeAddListIdx);
2734 if(BuildAndSendE2SetupRsp(duDb, transId, tmpE2NodeList) !=ROK)
2736 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
2739 /*******************************************************************
2741 * @brief Deallocate the memory allocated for E2 Reset Response
2745 * Function : FreeE2ResetResponse
2748 * - freeing the memory allocated for E2ResetResponse
2750 * @params[in] E2AP_PDU_t *e2apMsg
2751 * @return ROK - success
2754 * ****************************************************************/
2755 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
2758 ResetResponseE2_t *resetResponse =NULLP;
2760 if(e2apMsg != NULLP)
2762 if(e2apMsg->choice.successfulOutcome != NULLP)
2764 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
2765 if(resetResponse->protocolIEs.list.array)
2767 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
2769 if(resetResponse->protocolIEs.list.array[ieIdx])
2771 RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
2774 RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
2776 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2778 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2782 /*******************************************************************
2784 * @brief Buld and send the Reset Response msg
2788 * Function : BuildAndSendResetResponse
2791 * - Buld and send the Reset Response Message
2796 * @return ROK - success
2799 * ****************************************************************/
2800 uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId)
2802 uint8_t ieIdx = 0, elementCnt = 0;
2803 uint8_t ret = RFAILED;
2804 E2AP_PDU_t *e2apMsg = NULLP;
2805 ResetResponseE2_t *resetResponse=NULL;
2806 asn_enc_rval_t encRetVal; /* Encoder return value */
2808 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
2811 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2812 if(e2apMsg == NULLP)
2814 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
2817 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
2819 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2820 if(e2apMsg->choice.successfulOutcome == NULLP)
2822 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
2826 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
2827 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2828 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
2829 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
2832 resetResponse->protocolIEs.list.count = elementCnt;
2833 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
2834 RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
2835 if(!resetResponse->protocolIEs.list.array)
2837 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
2841 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
2843 RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
2844 if(!resetResponse->protocolIEs.list.array[ieIdx])
2846 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
2850 if(ieIdx < elementCnt)
2854 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2855 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
2856 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
2857 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
2859 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2861 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2863 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2864 if(encRetVal.encoded == ENCODE_FAIL)
2866 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
2867 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2872 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
2873 for(int i=0; i< encBufSize; i++)
2875 DU_LOG("%x",encBuf[i]);
2880 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2882 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
2890 FreeE2ResetResponse(e2apMsg);
2894 /*******************************************************************
2896 * @brief deallocate the memory allocated in building the
2897 * Service Query message
2901 * Function : FreeRicServiceQuery
2903 * Functionality: deallocate the memory allocated in building
2904 * Ric Service Query message
2906 * @params[in] E2AP_PDU_t *e2apMsg
2909 * ****************************************************************/
2911 void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg)
2913 uint8_t arrIdx = 0, ranFuncIdx=0;
2914 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
2915 RICserviceQuery_t *ricServiceQuery=NULL;
2919 if(e2apMsg->choice.initiatingMessage)
2921 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
2922 if(ricServiceQuery->protocolIEs.list.array)
2924 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
2926 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
2928 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
2930 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2932 ranFuncAcceptedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2933 if(ranFuncAcceptedList->list.array)
2935 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
2937 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
2939 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
2943 case RICserviceQuery_IEs__value_PR_TransactionID:
2948 RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
2951 RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
2953 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2955 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2959 /*******************************************************************
2961 * @brief build and send the ric service Query
2965 * Function : BuildAndSendRicServiceQuery
2967 * Functionality: build and send the ric service Query
2968 * @return ROK - success
2969 * RFAILED - Acknowledge
2971 ******************************************************************/
2973 uint8_t BuildAndSendRicServiceQuery(DuDb *duDb)
2977 uint8_t ret = RFAILED;
2978 bool memAllocFailed = false;
2979 E2AP_PDU_t *e2apMsg = NULL;
2980 asn_enc_rval_t encRetVal;
2981 RICserviceQuery_t *ricServiceQuery;
2983 DU_LOG("\nINFO --> E2AP : Building Ric service Query\n");
2986 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2987 if(e2apMsg == NULLP)
2989 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2992 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2993 RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2));
2994 if(e2apMsg->choice.initiatingMessage == NULLP)
2996 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3000 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery;
3001 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
3002 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery;
3003 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
3006 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
3007 if(duDb->numOfRanFunction)
3010 ricServiceQuery->protocolIEs.list.count = elementCnt;
3011 ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*);
3013 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
3014 if(ricServiceQuery->protocolIEs.list.array == NULLP)
3016 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
3020 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3022 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
3023 if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP)
3025 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
3026 memAllocFailed = true;
3030 if(memAllocFailed == true)
3032 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
3038 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3039 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3040 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID;
3041 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb);
3043 if(duDb->numOfRanFunction)
3045 /* Accepted RAN function Id */
3047 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
3048 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3049 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List;
3050 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK)
3052 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
3057 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3058 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3060 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3062 /* Check encode results */
3063 if(encRetVal.encoded == ENCODE_FAIL)
3065 DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
3066 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3071 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
3072 for(int i=0; i< encBufSize; i++)
3074 DU_LOG("%x",encBuf[i]);
3078 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
3080 DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed");
3087 FreeRicServiceQuery(e2apMsg);
3091 /*******************************************************************
3093 * @brief deallocate the memory allocated in RicServiceUpdateFailure
3097 * Function : FreeRicServiceUpdateFailure
3099 * Functionality: deallocate the memory allocated in RicServiceUpdatefailure
3101 * @params[in] E2AP_PDU_t *e2apMsg
3104 * ****************************************************************/
3106 void FreeRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
3109 RICserviceUpdateFailure_t *ricServiceUpdateFailure=NULL;
3113 if(e2apMsg->choice.unsuccessfulOutcome)
3115 ricServiceUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
3116 if(ricServiceUpdateFailure->protocolIEs.list.array)
3118 for(arrIdx=0; arrIdx<ricServiceUpdateFailure->protocolIEs.list.count; arrIdx++)
3120 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
3122 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array, ricServiceUpdateFailure->protocolIEs.list.size);
3124 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3126 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3130 /*******************************************************************
3132 * @brief build and send the ric service update failure
3136 * Function : BuildAndSendRicServiceUpdateFailure
3138 * Functionality: build and send the ric service update failure
3139 * @return ROK - success
3142 ******************************************************************/
3144 uint8_t BuildAndSendRicServiceUpdateFailure(uint32_t duId, int8_t transId, CauseE2_PR causePresent, uint8_t reason)
3147 E2AP_PDU_t *e2apMsg = NULL;
3148 asn_enc_rval_t encRetVal;
3149 uint8_t ret = RFAILED;
3151 uint8_t elementCnt=0;
3152 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
3154 DU_LOG("\nINFO --> E2AP : Building Ric service update failure\n");
3157 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3158 if(e2apMsg == NULLP)
3160 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3163 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3164 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
3165 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3167 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3171 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
3172 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3173 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure;
3174 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
3177 ricServiceFailure->protocolIEs.list.count = elementCnt;
3178 ricServiceFailure->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateFailure_IEs_t *);
3180 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array, ricServiceFailure->protocolIEs.list.size);
3181 if(ricServiceFailure->protocolIEs.list.array == NULLP)
3183 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3187 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3189 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
3190 if(ricServiceFailure->protocolIEs.list.array[arrIdx] == NULLP)
3192 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3196 if(arrIdx<elementCnt)
3198 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3204 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3205 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3206 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TransactionID;
3207 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
3210 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
3211 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3212 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_CauseE2;
3213 fillE2FailureCause(&ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, causePresent, reason);
3216 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
3217 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
3218 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TimeToWaitE2;
3219 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
3221 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3222 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3224 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3226 /* Check encode results */
3227 if(encRetVal.encoded == ENCODE_FAIL)
3229 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\
3230 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3235 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n");
3236 for(int i=0; i< encBufSize; i++)
3238 DU_LOG("%x",encBuf[i]);
3242 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
3244 DU_LOG("\nERROR --> E2AP : Sending RIC service update failed");
3251 FreeRicServiceUpdateFailure(e2apMsg);
3256 /*******************************************************************
3258 * @brief deallocate the memory allocated in RicServiceUpdateAck(
3262 * Function : FreeRicServiceUpdateAck
3264 * Functionality: deallocate the memory allocated in RicServiceUpdateAck
3266 * @params[in] E2AP_PDU_t *e2apMsg
3269 * ****************************************************************/
3271 void FreeRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
3273 uint8_t arrIdx = 0, ranFuncIdx=0;
3274 RANfunctionsID_List_t *acceptedList=NULL;
3275 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
3276 RANfunctionsIDcause_List_t *rejectedList=NULL;
3280 if(e2apMsg->choice.successfulOutcome)
3282 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
3283 if(ricServiceUpdateAck->protocolIEs.list.array)
3285 for(arrIdx=0; arrIdx<ricServiceUpdateAck->protocolIEs.list.count; arrIdx++)
3287 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx])
3289 switch(ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id)
3291 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
3293 acceptedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3294 if(acceptedList->list.array)
3296 for(ranFuncIdx=0;ranFuncIdx<acceptedList->list.count; ranFuncIdx++)
3298 RIC_FREE(acceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
3300 RIC_FREE(acceptedList->list.array, acceptedList->list.size);
3305 case ProtocolIE_IDE2_id_RANfunctionsRejected:
3307 rejectedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
3308 if(rejectedList->list.array)
3310 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
3312 RIC_FREE(rejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
3314 RIC_FREE(rejectedList->list.array, rejectedList->list.size);
3319 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
3322 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
3324 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
3326 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3330 /*******************************************************************
3332 * @brief Build RAN function rejected list
3336 * Function : BuildRanFunctionRejectedList
3338 * Functionality: Build RAN function rejected list
3341 * Count of ran functions to be rejected in the list
3342 * Received list of RAN functions
3344 * @return ROK - success
3346 * ****************************************************************/
3348 uint8_t BuildRanFunctionRejectedList(uint8_t count, RanFunction *ranFunRejectedList, RANfunctionsIDcause_List_t *ranFuncRejectedList)
3350 uint8_t ranFuncIdx = 0;
3351 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
3353 ranFuncRejectedList->list.count = count;
3355 ranFuncRejectedList->list.size = ranFuncRejectedList->list.count*sizeof(RANfunctionIDcause_ItemIEs_t*);
3356 RIC_ALLOC(ranFuncRejectedList->list.array, ranFuncRejectedList->list.size);
3357 if(ranFuncRejectedList->list.array == NULLP)
3359 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array");
3363 for(ranFuncIdx = 0; ranFuncIdx< ranFuncRejectedList->list.count; ranFuncIdx++)
3365 RIC_ALLOC(ranFuncRejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
3366 if(ranFuncRejectedList->list.array[ranFuncIdx] == NULLP)
3368 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array item");
3371 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[ranFuncIdx];
3372 ranFuncRejectedItemIe->id = ProtocolIE_IDE2_id_RANfunctionIEcause_Item;
3373 ranFuncRejectedItemIe->criticality= CriticalityE2_ignore;
3374 ranFuncRejectedItemIe->value.present = RANfunctionIDcause_ItemIEs__value_PR_RANfunctionIDcause_Item;
3375 ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID = ranFunRejectedList[ranFuncIdx].id;
3376 fillE2FailureCause(&ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.cause, CauseE2_PR_ricService,\
3377 CauseE2RICservice_ran_function_not_supported);
3383 /*******************************************************************
3385 * @brief build and send the ric service update Acknowledge
3389 * Function : BuildAndSendRicServiceUpdateAcknowledge
3391 * Functionality: build and send the ric service update Acknowledge
3392 * @return ROK - success
3393 * RFAILED - Acknowledge
3395 ******************************************************************/
3397 uint8_t BuildAndSendRicServiceUpdateAcknowledge(DuDb *duDb, int8_t transId, RicTmpRanFunList ricRanFuncList)
3399 E2AP_PDU_t *e2apMsg = NULL;
3400 asn_enc_rval_t encRetVal;
3401 uint8_t arrIdx=0, elementCnt=0, ret=RFAILED;;
3402 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
3404 DU_LOG("\nINFO --> E2AP : Building Ric service update Acknowledge\n");
3407 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3408 if(e2apMsg == NULLP)
3410 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3413 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
3414 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(struct SuccessfulOutcomeE2));
3415 if(e2apMsg->choice.successfulOutcome == NULLP)
3417 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3421 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
3422 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
3423 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge;
3424 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
3427 if(ricRanFuncList.numOfRanFunAccepted)
3429 if(ricRanFuncList.numOfRanFuneRejected)
3433 ricServiceUpdateAck->protocolIEs.list.count = elementCnt;
3434 ricServiceUpdateAck->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateAcknowledge_IEs_t*);
3436 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
3437 if(ricServiceUpdateAck->protocolIEs.list.array == NULLP)
3439 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3443 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3445 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
3446 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
3448 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3452 if(arrIdx<elementCnt)
3454 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3460 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3461 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3462 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_TransactionID;
3463 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
3465 if(ricRanFuncList.numOfRanFunAccepted)
3467 /* Accepted RAN function List */
3469 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
3470 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3471 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsID_List;
3472 if(BuildRanFunctionAcceptedList(duDb, ricRanFuncList.numOfRanFunAccepted, ricRanFuncList.ranFunAcceptedList,\
3473 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceUpdate)!=ROK)
3475 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
3480 if(ricRanFuncList.numOfRanFuneRejected)
3482 /* RAN Functions Rejected List */
3484 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsRejected;
3485 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3486 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsIDcause_List;
3487 if(BuildRanFunctionRejectedList(ricRanFuncList.numOfRanFuneRejected, ricRanFuncList.ranFunRejectedList, \
3488 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List)!=ROK)
3490 DU_LOG("\nERROR --> E2AP : Failed to build Ran function rejected list");
3496 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3497 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3499 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3501 /* Check encode results */
3502 if(encRetVal.encoded == ENCODE_FAIL)
3504 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\
3505 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3510 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\n");
3511 for(int i=0; i< encBufSize; i++)
3513 DU_LOG("%x",encBuf[i]);
3517 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
3519 DU_LOG("\nERROR --> E2AP : Sending RIC service update ack failed");
3525 FreeRicServiceUpdateAck(e2apMsg);
3529 /*******************************************************************
3531 * @brief process the RIC service update
3535 * Function : ProcRicserviceUpdate
3537 * Functionality: process the RIC service update
3539 * @return ROK - success
3542 ******************************************************************/
3544 void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate)
3546 RicTmpRanFunList ricRanFuncList;
3549 uint8_t duIdx = 0, elementCnt =0, arrIdx = 0;
3550 uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0;
3551 RanFunction *ranFuncDb = NULLP;
3552 RANfunction_ItemIEs_t *ranFuncItemIe =NULL;
3553 RANfunction_Item_t *ranFuncItem =NULL;
3554 RANfunctionID_Item_t *ranFuncIdItem=NULL;
3555 RANfunctions_List_t *ranFuncList=NULL;
3556 RANfunctionsID_List_t *deleteList=NULL;
3557 RANfunctionID_ItemIEs_t *delRanFuncItem=NULL;
3559 SEARCH_DU_DB(duIdx, duId, duDb);
3562 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
3565 memset(&ricRanFuncList, 0, sizeof(RicTmpRanFunList));
3567 if(!ricServiceUpdate)
3569 DU_LOG("\nERROR --> E2AP : ricServiceUpdate pointer is null");
3573 if(!ricServiceUpdate->protocolIEs.list.array)
3575 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array pointer is null");
3578 elementCnt = ricServiceUpdate->protocolIEs.list.count;
3579 for(arrIdx=0; arrIdx<ricServiceUpdate->protocolIEs.list.count; arrIdx++)
3581 if(!ricServiceUpdate->protocolIEs.list.array[arrIdx])
3583 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx);
3587 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
3589 case ProtocolIE_IDE2_id_TransactionID:
3591 transId = ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
3593 if(transId < 0 || transId > 255)
3595 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
3601 case ProtocolIE_IDE2_id_RANfunctionsAdded:
3603 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
3605 if(ranFuncList->list.array)
3607 for(ranFuncIdx=0;ranFuncIdx<ranFuncList->list.count; ranFuncIdx++)
3609 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
3610 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
3612 /* Adding the ran function in temporary list */
3613 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
3614 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
3615 ricRanFuncList.numOfRanFunAccepted++;
3617 /* Adding the new ran function in DB*/
3618 duDb->ranFunction[ranFuncItem->ranFunctionID-1].id = ranFuncItem->ranFunctionID;
3619 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
3620 duDb->numOfRanFunction++;
3622 /* Calculating total number of ran fuctions which are received for addition */
3623 recvdRanFuncCount++;
3629 case ProtocolIE_IDE2_id_RANfunctionsModified:
3632 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
3633 if(ranFuncList->list.array)
3635 for(ranFuncIdx = 0; ranFuncIdx< ranFuncList->list.count; ranFuncIdx++)
3637 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
3638 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
3639 if(fetchRanFuncFromRanFuncId(duDb, ranFuncItem->ranFunctionID) == NULLP)
3641 /* Calculating total number of ran fuctions which are not present */
3642 failedRanFuncCount++;
3644 /* Adding the ran function in temporary list */
3645 ricRanFuncList.ranFunRejectedList[ricRanFuncList.numOfRanFuneRejected].id = ranFuncItem->ranFunctionID;
3646 ricRanFuncList.numOfRanFuneRejected++;
3651 /* Adding the ran function in temporary list */
3652 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
3653 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
3654 ricRanFuncList.numOfRanFunAccepted++;
3656 /* Updating the new ran function in DB*/
3657 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
3659 /* Calculating total number of ran fuctions which are received for modification */
3660 recvdRanFuncCount++;
3665 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
3668 deleteList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3669 if(deleteList->list.array)
3671 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
3673 delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx];
3674 ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item;
3675 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncIdItem->ranFunctionID);
3678 memset(ranFuncDb, 0, sizeof(RanFunction));
3679 duDb->numOfRanFunction--;
3682 /* Calculating total number of ran fuctions which are received for deletion */
3683 recvdRanFuncCount++;
3691 DU_LOG("\nERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id);
3697 /* Sending RIC Service Update Failed if all RAN Functions received fail or if any IE processing fails
3698 * Else sending RIC Service Update Acknowledge */
3699 if((elementCnt > arrIdx) ||((recvdRanFuncCount > 0) && (recvdRanFuncCount == failedRanFuncCount)))
3701 if(BuildAndSendRicServiceUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
3703 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update Failure");
3709 if(BuildAndSendRicServiceUpdateAcknowledge(duDb, transId, ricRanFuncList) != ROK)
3711 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update acknowledge");
3717 /*******************************************************************
3719 * @brief Processing RIC subscription failure from DU
3723 * Function : ProcRicSubscriptionFailure
3725 * Functionality: Processing RIC subscription failure from DU
3727 * @param ID of DU from which message was sent
3728 * RIC Subscription failure message
3729 * @return ROK - success
3732 ******************************************************************/
3733 uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricSubscriptionFailure)
3735 uint8_t ieIdx = 0, duIdx = 0;
3736 uint8_t ranFuncId = 0;
3738 RanFunction *ranFuncDb = NULLP;
3739 RicSubscription *ricSubs = NULLP;
3740 CmLList *ricSubsNode = NULLP;
3741 RicRequestId ricReqId;
3742 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3744 DU_LOG("\nINFO --> E2AP : Received RIC subscription failure");
3746 SEARCH_DU_DB(duIdx, duId, duDb);
3749 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
3753 memset(&ricReqId, 0, sizeof(RicRequestId));
3754 if(ricSubscriptionFailure)
3756 if(ricSubscriptionFailure->protocolIEs.list.array)
3758 for(ieIdx=0; ieIdx<ricSubscriptionFailure->protocolIEs.list.count; ieIdx++)
3760 if(ricSubscriptionFailure->protocolIEs.list.array[ieIdx])
3762 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[ieIdx];
3763 switch(ricSubscriptionFailure->protocolIEs.list.array[ieIdx]->id)
3765 case ProtocolIE_IDE2_id_RICrequestID:
3767 ricReqId.requestorId = ricSubsFailIe->value.choice.RICrequestID.ricRequestorID;
3768 ricReqId.instanceId = ricSubsFailIe->value.choice.RICrequestID.ricInstanceID;
3771 case ProtocolIE_IDE2_id_RANfunctionID:
3773 ranFuncId = ricSubsFailIe->value.choice.RANfunctionID;
3774 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
3777 DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId);
3782 /* Remove subscription entry from RAN Function */
3783 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
3786 cmLListDelFrm(&ranFuncDb->subscriptionList, ricSubsNode);
3787 deleteRicSubscriptionNode(ricSubsNode);
3792 case ProtocolIE_IDE2_id_CauseE2:
3794 /* No handling required as of now since this is a stub */
3804 /*******************************************************************
3806 * @brief Free RIC Subscription Modification Refuse
3810 * Function : FreeRicSubsModRefuse
3812 * Functionality: Free RIC Subscription Modification Refuse
3814 * @param E2AP Message PDU to be freed
3817 ******************************************************************/
3818 void FreeRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
3821 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
3825 if(e2apMsg->choice.unsuccessfulOutcome)
3827 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
3828 if(ricSubsModRefuse->protocolIEs.list.array)
3830 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
3832 RIC_FREE(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
3834 RIC_FREE(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
3836 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
3838 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3842 /*******************************************************************
3844 * @brief Build And Send RIC Subscription Modification Refuse
3848 * Function : BuildAndSendRicSubsModRefuse
3850 * Functionality: Build And Send RIC Subscription Modification Refuse
3853 * RIC Request ID of subscription
3857 * @return ROK - success
3860 ******************************************************************/
3861 uint8_t BuildAndSendRicSubsModRefuse(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, CauseE2_PR causeType, \
3864 uint8_t ieIdx = 0, elementCnt = 0;
3865 uint8_t ret = RFAILED;
3866 E2AP_PDU_t *e2apMsg = NULL;
3867 asn_enc_rval_t encRetVal;
3868 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
3869 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
3871 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Refuse\n");
3874 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3875 if(e2apMsg == NULLP)
3877 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3880 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3881 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
3882 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3884 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3888 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
3889 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3890 e2apMsg->choice.unsuccessfulOutcome->value.present = \
3891 UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse;
3892 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
3895 ricSubsModRefuse->protocolIEs.list.count = elementCnt;
3896 ricSubsModRefuse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRefuse_IEs_t *);
3897 RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
3898 if(!ricSubsModRefuse->protocolIEs.list.array)
3900 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3904 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
3906 RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
3907 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
3909 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3914 /* RIC Request ID */
3916 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3917 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RICrequestID;
3918 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3919 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RICrequestID;
3920 ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3921 ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3923 /* RAN Function ID */
3925 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3926 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3927 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3928 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RANfunctionID;
3929 ricSubsModRefuseIe->value.choice.RANfunctionID = ranFuncId;
3933 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3934 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_CauseE2;
3935 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3936 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_CauseE2;
3937 fillE2FailureCause(&ricSubsModRefuseIe->value.choice.CauseE2, causeType, cause);
3939 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3940 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3942 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3944 /* Check encode results */
3945 if(encRetVal.encoded == ENCODE_FAIL)
3947 DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification refuse (at %s)\n",\
3948 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3953 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification refuse\n");
3954 for(int i=0; i< encBufSize; i++)
3956 DU_LOG("%x",encBuf[i]);
3960 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
3962 DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Refused");
3969 FreeRicSubsModRefuse(e2apMsg);
3973 /*******************************************************************
3975 * @brief Free memory for RIC Subscription Modification Confirm
3979 * Function : FreeRicSubsModConfirm
3981 * Functionality: Free memory for RIC subscription modification
3984 * @param E2AP Message PDU to be freed
3987 ******************************************************************/
3988 void FreeRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
3990 uint8_t ieIdx = 0, arrIdx=0;
3991 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
3992 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
3993 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
3994 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
3995 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
3996 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
4000 if(e2apMsg->choice.successfulOutcome)
4002 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
4003 if(ricSubsModCfm->protocolIEs.list.array)
4005 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
4007 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
4009 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4010 switch(ricSubsModCfmIe->id)
4012 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
4014 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
4015 if(modCfmList->list.array)
4017 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
4019 RIC_FREE(modCfmList->list.array[arrIdx], \
4020 sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
4022 RIC_FREE(modCfmList->list.array, modCfmList->list.size);
4027 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
4029 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
4030 if(modRefusedList->list.array)
4032 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
4034 RIC_FREE(modRefusedList->list.array[arrIdx], \
4035 sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
4037 RIC_FREE(modRefusedList->list.array, modRefusedList->list.size);
4042 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
4044 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
4045 if(rmvCfmList->list.array)
4047 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
4049 RIC_FREE(rmvCfmList->list.array[arrIdx], \
4050 sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
4052 RIC_FREE(rmvCfmList->list.array, rmvCfmList->list.size);
4057 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
4059 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
4060 if(rmvFailList->list.array)
4062 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
4064 RIC_ALLOC(rmvFailList->list.array[arrIdx], \
4065 sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
4067 RIC_FREE(rmvFailList->list.array, rmvFailList->list.size);
4076 RIC_FREE(ricSubsModCfmIe, sizeof(RICsubscriptionModificationConfirm_IEs_t));
4079 RIC_FREE(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
4081 RIC_FREE(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
4083 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4087 /*******************************************************************
4089 * @brief Fill the list of actions confirmed for modification
4093 * Function : fillActionModConfirmedList
4095 * Functionality: Fill the list of actions confirmed for modification
4097 * @param List to be filled
4099 * Source list of actions
4100 * @return ROK - success
4103 ******************************************************************/
4104 uint8_t fillActionModConfirmedList(RICactions_ConfirmedForModification_List_t *modCfmList, uint8_t numActions, \
4105 uint8_t *actionModifiedList)
4108 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
4110 modCfmList->list.count = numActions;
4111 modCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForModification_ItemIEs_t *);
4112 RIC_ALLOC(modCfmList->list.array, modCfmList->list.size);
4113 if(!modCfmList->list.array)
4115 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4119 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
4121 RIC_ALLOC(modCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
4122 if(!modCfmList->list.array[arrIdx])
4124 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4128 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
4129 modCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForModification_Item;
4130 modCfmListItem->criticality = CriticalityE2_ignore;
4131 modCfmListItem->value.present = \
4132 RICaction_ConfirmedForModification_ItemIEs__value_PR_RICaction_ConfirmedForModification_Item;
4133 modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID = actionModifiedList[arrIdx];
4139 /*******************************************************************
4141 * @brief Fill the list of actions refused to be modified
4145 * Function : fillActionModRefusedList
4147 * Functionality: Fill the list of actions refused to be modified
4149 * @param List to be filled
4151 * Source list of actions refused tobe modified
4152 * @return ROK - success
4155 ******************************************************************/
4156 uint8_t fillActionModRefusedList(RICactions_RefusedToBeModified_List_t *modRefusedList, uint8_t numActions, \
4157 ActionFailed *actionModFailedList)
4160 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
4162 modRefusedList->list.count = numActions;
4163 modRefusedList->list.size = numActions * sizeof(RICaction_RefusedToBeModified_ItemIEs_t *);
4164 RIC_ALLOC(modRefusedList->list.array, modRefusedList->list.size);
4165 if(!modRefusedList->list.array)
4167 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4171 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
4173 RIC_ALLOC(modRefusedList->list.array[arrIdx], sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
4174 if(!modRefusedList->list.array[arrIdx])
4176 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4180 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
4181 modRefusedListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeModified_Item;
4182 modRefusedListItem->criticality = CriticalityE2_ignore;
4183 modRefusedListItem->value.present = \
4184 RICaction_RefusedToBeModified_ItemIEs__value_PR_RICaction_RefusedToBeModified_Item;
4185 modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID = \
4186 actionModFailedList[arrIdx].actionId;
4187 fillE2FailureCause(&modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.cause, \
4188 actionModFailedList[arrIdx].failureType, actionModFailedList[arrIdx].cause);
4194 /*******************************************************************
4196 * @brief Fill the list of action confirmed for removal
4200 * Function : fillActionRemovalConfirmedList
4202 * Functionality: Fill the list of action confirmed for removal
4204 * @param List to be filled
4206 * Source list of actions removed
4207 * @return ROK - success
4210 ******************************************************************/
4211 uint8_t fillActionRemovalConfirmedList(RICactions_ConfirmedForRemoval_List_t *rmvCfmList, uint8_t numActions, \
4212 uint8_t *actionRemovedList)
4215 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
4217 rmvCfmList->list.count = numActions;
4218 rmvCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t *);
4219 RIC_ALLOC(rmvCfmList->list.array, rmvCfmList->list.size);
4220 if(!rmvCfmList->list.array)
4222 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4226 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
4228 RIC_ALLOC(rmvCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
4229 if(!rmvCfmList->list.array[arrIdx])
4231 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4235 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
4236 rmvCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForRemoval_Item;
4237 rmvCfmListItem->criticality = CriticalityE2_ignore;
4238 rmvCfmListItem->value.present = \
4239 RICaction_ConfirmedForRemoval_ItemIEs__value_PR_RICaction_ConfirmedForRemoval_Item;
4240 rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID = actionRemovedList[arrIdx];
4246 /*******************************************************************
4248 * @brief Fill the list of actions refused to be removed
4252 * Function : fillActionRemovalRefusedList
4254 * Functionality: Fill the list of actions refused to be removed
4256 * @param List to be filled
4258 * Source list of actions refused to be removed
4259 * @return ROK - success
4262 ******************************************************************/
4263 uint8_t fillActionRemovalRefusedList(RICactions_RefusedToBeRemoved_List_t *rmvFailList, \
4264 uint8_t numActions, ActionFailed *actionRmvlFailList)
4267 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
4269 rmvFailList->list.count = numActions;
4270 rmvFailList->list.size = numActions * sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t *);
4271 RIC_ALLOC(rmvFailList->list.array, rmvFailList->list.size);
4272 if(!rmvFailList->list.array)
4274 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4278 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
4280 RIC_ALLOC(rmvFailList->list.array[arrIdx], sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
4281 if(!rmvFailList->list.array[arrIdx])
4283 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4287 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
4288 rmvFailListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeRemoved_Item;
4289 rmvFailListItem->criticality = CriticalityE2_ignore;
4290 rmvFailListItem->value.present = \
4291 RICaction_RefusedToBeRemoved_ItemIEs__value_PR_RICaction_RefusedToBeRemoved_Item;
4292 rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID = actionRmvlFailList[arrIdx].actionId;
4293 fillE2FailureCause(&rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.cause, \
4294 actionRmvlFailList[arrIdx].failureType, actionRmvlFailList[arrIdx].cause);
4301 /*******************************************************************
4303 * @brief Build And Send RIC Subscription Modification Confirm
4307 * Function : BuildAndSendRicSubsModConfirm
4309 * Functionality: Build And Send RIC Subscription Modification Confirm
4312 * RIC Request ID of subscription
4314 * Temporary source action list
4315 * @return ROK - success
4318 ******************************************************************/
4319 uint8_t BuildAndSendRicSubsModConfirm(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, RicTmpActionList tmpActionList)
4321 uint8_t ieIdx = 0, elementCnt = 0;
4322 uint8_t ret = RFAILED;
4323 E2AP_PDU_t *e2apMsg = NULLP;
4324 asn_enc_rval_t encRetVal;
4325 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
4326 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
4328 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Confirm\n");
4331 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4332 if(e2apMsg == NULLP)
4334 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4338 /* Successful Outcome */
4339 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
4340 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
4341 if(e2apMsg->choice.successfulOutcome == NULLP)
4343 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4347 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
4348 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
4349 e2apMsg->choice.successfulOutcome->value.present = \
4350 SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm;
4351 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
4354 if(tmpActionList.numActionModified)
4356 if(tmpActionList.numActionModFailed)
4358 if(tmpActionList.numActionRemoved)
4360 if(tmpActionList.numActionRemovalFailed)
4363 ricSubsModCfm->protocolIEs.list.count = elementCnt;
4364 ricSubsModCfm->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationConfirm_IEs_t *);
4365 RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
4366 if(!ricSubsModCfm->protocolIEs.list.array)
4368 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4372 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
4374 RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationConfirm_IEs_t));
4375 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
4377 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4382 /* RIC Request ID */
4384 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4385 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICrequestID;
4386 ricSubsModCfmIe->criticality = CriticalityE2_reject;
4387 ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RICrequestID;
4388 ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
4389 ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
4391 /* RAN Function ID */
4393 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4394 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RANfunctionID;
4395 ricSubsModCfmIe->criticality = CriticalityE2_reject;
4396 ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RANfunctionID;
4397 ricSubsModCfmIe->value.choice.RANfunctionID = ranFuncId;
4399 /* RIC Actions List confirmed for modification */
4400 if(tmpActionList.numActionModified)
4403 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4404 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List;
4405 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4406 ricSubsModCfmIe->value.present = \
4407 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForModification_List;
4408 if(fillActionModConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List, \
4409 tmpActionList.numActionModified, tmpActionList.actionModifiedList) != ROK)
4411 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Modification List", __func__);
4416 /* RIC Actions List refured to be modified */
4417 if(tmpActionList.numActionModFailed)
4420 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4421 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List;
4422 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4423 ricSubsModCfmIe->value.present = \
4424 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeModified_List;
4425 if(fillActionModRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List, \
4426 tmpActionList.numActionModFailed, tmpActionList.actionModFailedList) != ROK)
4428 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Refused to be Modified List", __func__);
4433 /* RIC Actions List confirmed for removal */
4434 if(tmpActionList.numActionRemoved)
4437 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4438 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List;
4439 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4440 ricSubsModCfmIe->value.present = \
4441 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForRemoval_List;
4442 if(fillActionRemovalConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List, \
4443 tmpActionList.numActionRemoved, tmpActionList.actionRemovedList) != ROK)
4445 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Removal List", __func__);
4450 /* RIC Actions List Refused to be removed */
4451 if(tmpActionList.numActionRemovalFailed)
4454 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4455 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List;
4456 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4457 ricSubsModCfmIe->value.present = \
4458 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeRemoved_List;
4459 if(fillActionRemovalRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List, \
4460 tmpActionList.numActionRemovalFailed, tmpActionList.actionRemovalFailedList) != ROK)
4462 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Failed to be Removed List", __func__);
4467 /* Print and encode E2AP Message PDU */
4468 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4469 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4471 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
4473 /* Check encode results */
4474 if(encRetVal.encoded == ENCODE_FAIL)
4476 DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification confirm (at %s)\n",\
4477 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4482 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification confirm\n");
4483 for(int i=0; i< encBufSize; i++)
4485 DU_LOG("%x",encBuf[i]);
4489 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
4491 DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Confirm");
4499 FreeRicSubsModConfirm(e2apMsg);
4503 /*******************************************************************
4505 * @brief Processing of RIC Subscription Modification Required
4509 * Function : ProcRicSubsModReqd
4511 * Functionality: Processing of RIC Subscription Modification Required
4512 * As of now, we do not identify any scenario where this message
4513 * shall be sent by DU. Hence, bare minimum handling has been
4517 * RIC Subscription Modification Required IEs
4518 * @return ROK-success
4521 ******************************************************************/
4522 uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t *ricSubsModReqd)
4524 uint8_t ieIdx = 0, actionIdx = 0, duIdx = 0;
4528 RicRequestId ricReqId;
4529 RanFunction *ranFuncDb = NULLP;
4530 RicSubscription *ricSubs = NULLP;
4531 CmLList *ricSubsNode = NULLP;
4532 CmLList *actionNode = NULLP;
4533 ActionInfo *action = NULLP;
4534 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
4535 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
4536 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
4537 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULLP;
4538 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULLP;
4539 RicTmpActionList tmpActionList;
4541 memset(&ricReqId, 0, sizeof(RicRequestId));
4542 memset(&tmpActionList, 0, sizeof(RicTmpActionList));
4544 SEARCH_DU_DB(duIdx, duId, duDb);
4547 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
4551 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
4553 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
4554 switch(ricSubsModReqdIe->id)
4556 case ProtocolIE_IDE2_id_RICrequestID:
4558 ricReqId.requestorId = ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID;
4559 ricReqId.instanceId = ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID;
4562 case ProtocolIE_IDE2_id_RANfunctionID:
4564 ranFuncId = ricSubsModReqdIe->value.choice.RANfunctionID;
4565 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
4568 /* If RIC Subscription not found, send RIC Subscription modification refuse to DU */
4569 DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RIC Subscription not found");
4570 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
4571 CauseE2RICrequest_ran_function_id_invalid);
4575 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
4578 /* If RAN Function not found, send RIC Subscription modification refuse to DU */
4579 DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RAN Function ID [%d] not found",ranFuncId);
4580 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, \
4581 CauseE2_PR_ricRequest, CauseE2RICrequest_request_id_unknown);
4586 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
4588 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
4589 for(actionIdx = 0; actionIdx < actionToBeModList->list.count; actionIdx++)
4592 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[actionIdx];
4593 actionId = actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID;
4594 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
4597 /* No modification required as of now, hence directly adding to the list */
4598 tmpActionList.actionModifiedList[tmpActionList.numActionModified++] = actionId;
4602 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].actionId = actionId;
4603 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].failureType = \
4604 CauseE2_PR_ricRequest;
4605 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].cause = \
4606 CauseE2RICrequest_action_not_supported;
4607 tmpActionList.numActionModFailed++;
4612 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
4614 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
4615 for(actionIdx = 0; actionIdx < actionToBeRmvList->list.count; actionIdx++)
4618 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[actionIdx];
4619 actionId = actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID;
4620 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
4623 tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId;
4624 deleteActionSequence(action);
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, int8_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, transId = 0;
4909 uint8_t ret = RFAILED;
4910 E2AP_PDU_t *e2apMsg = NULLP;
4911 ResetRequestE2_t *resetReq = NULLP;
4912 asn_enc_rval_t encRetVal; /* Encoder return value */
4914 DU_LOG("\nINFO --> E2AP : Building Reset Request\n");
4918 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4919 if(e2apMsg == NULLP)
4921 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for E2AP-PDU failed");
4925 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4926 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4927 if(e2apMsg->choice.initiatingMessage == NULLP)
4929 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for initiatingMessage");
4933 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
4934 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4935 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
4936 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4939 resetReq->protocolIEs.list.count = elementCnt;
4940 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
4942 RIC_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4943 if(!resetReq->protocolIEs.list.array)
4945 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
4946 Reset Request IE array");
4950 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
4952 RIC_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4953 if(!resetReq->protocolIEs.list.array[ieIdx])
4955 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
4956 Reset Request IE array element");
4961 /* In case of failure */
4962 if(ieIdx < elementCnt)
4966 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4967 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
4968 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
4969 transId = assignTransactionId(duDb);
4970 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
4973 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
4974 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
4975 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
4976 fillE2FailureCause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
4978 /* Prints the Msg formed */
4979 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4981 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4983 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4985 if(encRetVal.encoded == ENCODE_FAIL)
4987 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
4988 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4993 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
4994 #ifdef DEBUG_ASN_PRINT
4995 for(int i=0; i< encBufSize; i++)
4997 printf("%x",encBuf[i]);
5001 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
5003 DU_LOG("\nERROR --> E2AP : Sending reset request failed");
5012 /* Free all memory */
5013 FreeResetRequest(e2apMsg);
5017 /******************************************************************
5019 * @brief Delete Ric subscription action
5023 * Function : deleteActionSequence
5025 * Functionality: Delete Ric subscription action
5027 * @params[in] Action info
5031 * ****************************************************************/
5032 void deleteActionSequence(CmLList *actionNode)
5034 ActionInfo *action = NULLP;
5038 action = (ActionInfo*)actionNode->node;
5039 memset(action, 0, sizeof(ActionInfo));
5040 RIC_FREE(actionNode->node, sizeof(ActionInfo));
5041 RIC_FREE(actionNode, sizeof(CmLList));
5045 /******************************************************************
5047 * @brief Delete Ric subscription action list
5051 * Function : deleteActionSequenceList
5053 * Functionality: Delete Ric subscription action list
5055 * @params[in] Action info list
5059 * ****************************************************************/
5060 void deleteActionSequenceList(CmLListCp *actionList)
5062 CmLList *actionNode=NULLP;
5064 CM_LLIST_FIRST_NODE(actionList, actionNode);
5067 cmLListDelFrm(actionList, actionNode);
5068 deleteActionSequence(actionNode);
5069 CM_LLIST_FIRST_NODE(actionList, actionNode);
5074 /******************************************************************
5076 * @brief Delete Ric subscription node
5080 * Function : deleteRicSubscriptionNode
5082 * Functionality: Delete Ric subscription node
5084 * @params[in] Ric subscription info
5088 * ****************************************************************/
5089 void deleteRicSubscriptionNode(CmLList *subscriptionNode)
5091 uint8_t actionIdx=0;
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, transId=0;
5223 RanFunction *ranFuncDb = NULLP;
5224 uint16_t ranFuncIdx = 0;
5226 SEARCH_DU_DB(duIdx, duId, duDb);
5229 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5235 DU_LOG("\nERROR --> E2AP : resetReq pointer is null");
5239 if(!resetReq->protocolIEs.list.array)
5241 DU_LOG("\nERROR --> E2AP : resetReq array pointer is null");
5245 for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
5247 if(resetReq->protocolIEs.list.array[ieIdx])
5249 switch(resetReq->protocolIEs.list.array[ieIdx]->id)
5251 case ProtocolIE_IDE2_id_TransactionID:
5253 transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5256 case ProtocolIE_IDE2_id_CauseE2:
5258 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
5260 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
5261 if(ranFuncDb->id > 0)
5263 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
5272 if(BuildAndSendResetResponse(duId, transId) !=ROK)
5274 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
5278 /*******************************************************************
5280 * @brief Free RIC Subscription Delete Request Message
5284 * Function : FreeRicSubscriptionDeleteRequest
5286 * Functionality: Free RIC Subscription Delete Request
5288 * @param E2AP Message PDU
5291 ******************************************************************/
5292 void FreeRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
5294 uint8_t ieIdx = 0, arrIdx = 0;
5295 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
5299 if(e2apMsg->choice.initiatingMessage)
5301 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
5302 if(ricSubsDelReq->protocolIEs.list.array)
5304 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
5306 RIC_FREE(ricSubsDelReq->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
5308 RIC_FREE(ricSubsDelReq->protocolIEs.list.array, ricSubsDelReq->protocolIEs.list.size);
5310 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5312 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
5316 /*******************************************************************
5318 * @brief Builds and Send RIC Subscription delete request
5322 * Function : BuildAndSendRicSubscriptionDeleteRequest
5324 * Functionality: Build and send RIC subscription delete request.
5327 * RIC subscription info to be deleted
5328 * @return ROK - success
5331 ******************************************************************/
5332 uint8_t BuildAndSendRicSubscriptionDeleteRequest(uint32_t duId, RicSubscription *ricSubsDb)
5334 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
5335 E2AP_PDU_t *e2apMsg = NULLP;
5336 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
5337 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
5338 asn_enc_rval_t encRetVal; /* Encoder return value */
5342 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Request Message\n");
5344 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5345 if(e2apMsg == NULLP)
5347 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
5351 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5352 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5353 if(e2apMsg->choice.initiatingMessage == NULLP)
5355 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
5358 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
5359 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5360 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest;
5362 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
5365 ricSubsDelReq->protocolIEs.list.count = elementCnt;
5366 ricSubsDelReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequest_IEs_t *);
5368 RIC_ALLOC(ricSubsDelReq->protocolIEs.list.array, ricSubsDelReq->protocolIEs.list.size);
5369 if(ricSubsDelReq->protocolIEs.list.array == NULLP)
5371 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
5375 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5377 RIC_ALLOC(ricSubsDelReq->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequest_IEs_t));
5378 if(ricSubsDelReq->protocolIEs.list.array[ieIdx] == NULLP)
5380 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
5381 __func__, ieIdx, __LINE__);
5385 if(ieIdx < elementCnt)
5388 /* RIC Request ID */
5390 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
5391 ricSubsDelReqIe->id = ProtocolIE_IDE2_id_RICrequestID;
5392 ricSubsDelReqIe->criticality = CriticalityE2_reject;
5393 ricSubsDelReqIe->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RICrequestID;
5394 ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID = ricSubsDb->requestId.requestorId;
5395 ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID = ricSubsDb->requestId.instanceId;
5397 /* RAN Function ID */
5399 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
5400 ricSubsDelReqIe->id = ProtocolIE_IDE2_id_RANfunctionID;
5401 ricSubsDelReqIe->criticality = CriticalityE2_reject;
5402 ricSubsDelReqIe->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RANfunctionID;
5403 ricSubsDelReqIe->value.choice.RANfunctionID = ricSubsDb->ranFuncId;
5405 /* Prints the Msg formed */
5406 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5407 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5409 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5410 if(encRetVal.encoded == ENCODE_FAIL)
5412 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Request Message (at %s)\n",\
5413 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5418 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Request Message \n");
5419 #ifdef DEBUG_ASN_PRINT
5420 for(int i=0; i< encBufSize; i++)
5422 printf("%x",encBuf[i]);
5427 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
5429 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Request Message");
5437 FreeRicSubscriptionDeleteRequest(e2apMsg);
5441 /*******************************************************************
5443 * @brief Processing of RIC Subscription Delete Required
5447 * Function : ProcRicSubsDeleteReqd
5449 * Functionality: Processing of RIC Subscription Delete Required
5450 * When received, RIC stub will initiate the RIC subscription
5451 * deletion procedure towards DU
5454 * RIC Subscription Delete Required IEs
5455 * @return ROK-success
5458 ******************************************************************/
5459 uint8_t ProcRicSubsDeleteReqd(uint32_t duId, RICsubscriptionDeleteRequired_t *ricSubsDelRqd)
5461 uint8_t ieIdx = 0, duIdx = 0;
5462 uint16_t arrIdx = 0;
5464 RicRequestId ricReqId;
5465 RanFunction *ranFuncDb = NULLP;
5466 RicSubscription *subsDb = NULLP;
5467 CmLList *ricSubsNode = NULLP;
5469 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
5470 RICsubscription_List_withCause_t *ricSubsList = NULLP;
5471 RICsubscription_withCause_Item_t *subsItem = NULLP;
5473 memset(&ricReqId, 0, sizeof(RicRequestId));
5477 DU_LOG("\nERROR --> E2AP : %s: Received NULL message", __func__);
5481 SEARCH_DU_DB(duIdx, duId, duDb);
5484 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5488 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
5490 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
5491 switch(ricSubsDelRqdIe->id)
5493 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
5495 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
5496 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
5498 subsItem = &(((RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[arrIdx])->\
5499 value.choice.RICsubscription_withCause_Item);
5500 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, subsItem->ranFunctionID);
5503 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%ld] not found", __func__, subsItem->ranFunctionID);
5507 ricReqId.requestorId = subsItem->ricRequestID.ricRequestorID;
5508 ricReqId.instanceId = subsItem->ricRequestID.ricInstanceID;
5509 subsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
5512 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%ld] Instance_ID [%ld]", \
5513 __func__, subsItem->ricRequestID.ricRequestorID, subsItem->ricRequestID.ricInstanceID);
5517 /* Delete RIC Subcription from RAN Function */
5518 cmLListDelFrm(&ranFuncDb->subscriptionList, ricSubsNode);
5520 /* Send RIC Subscription delete request and then free any memory
5521 * allocated to store subscription info at RIC */
5522 BuildAndSendRicSubscriptionDeleteRequest(duId, (RicSubscription *)ricSubsNode->node);
5523 deleteRicSubscriptionNode(ricSubsNode);
5536 /*******************************************************************
5538 * @brief Deallocate memory allocated for E2nodeConfigurationUpdate
5542 * Function : freeE2NodeConfigItem
5545 * - freeing the memory allocated for E2nodeConfigurationUpdate
5548 * uint8_t protocolIe
5549 * PTR to e2NodeCfg which is to be freed
5550 * @return ROK - success
5553 * ****************************************************************/
5555 void freeE2NodeConfigItem(uint8_t protocolIe, PTR e2NodeCfg)
5557 E2nodeComponentConfigurationAck_t *cfgAck =NULLP;
5558 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULLP;
5559 E2nodeComponentConfigAdditionAck_Item_t *e2NodeAdditionAckItemIe=NULLP;
5560 E2nodeComponentConfigRemovalAck_Item_t *e2NodeRemovalAckItemIe=NULLP;
5561 E2nodeComponentConfigUpdateAck_Item_t *e2NodeUpdateAckItemIe=NULLP;
5563 /* Extracting the component interface and configuration ack information from
5564 * e2NodeCfg based on the protocol id */
5567 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
5569 e2NodeAdditionAckItemIe= (E2nodeComponentConfigAdditionAck_Item_t*)e2NodeCfg;
5570 switch(e2NodeAdditionAckItemIe->e2nodeComponentInterfaceType)
5572 case E2nodeComponentInterfaceType_f1:
5574 f1InterfaceInfo = e2NodeAdditionAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5583 cfgAck = &e2NodeAdditionAckItemIe->e2nodeComponentConfigurationAck;
5586 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
5588 e2NodeUpdateAckItemIe = (E2nodeComponentConfigUpdateAck_Item_t*)e2NodeCfg;
5589 switch(e2NodeUpdateAckItemIe->e2nodeComponentInterfaceType)
5591 case E2nodeComponentInterfaceType_f1:
5593 f1InterfaceInfo = e2NodeUpdateAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5601 cfgAck = &e2NodeUpdateAckItemIe->e2nodeComponentConfigurationAck;
5604 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
5606 e2NodeRemovalAckItemIe= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
5607 switch(e2NodeRemovalAckItemIe->e2nodeComponentInterfaceType)
5609 case E2nodeComponentInterfaceType_f1:
5611 f1InterfaceInfo = e2NodeRemovalAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5619 cfgAck = &e2NodeRemovalAckItemIe->e2nodeComponentConfigurationAck;
5623 /* Freeing the memory allocated to component interface and configuration ack */
5626 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
5627 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
5630 switch(cfgAck->updateOutcome)
5632 case E2nodeComponentConfigurationAck__updateOutcome_success:
5634 case E2nodeComponentConfigurationAck__updateOutcome_failure:
5636 RIC_FREE(cfgAck->failureCauseE2, sizeof(CauseE2_t));
5643 /*******************************************************************
5645 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
5649 * Function : FreeE2NodeConfigUpdate
5652 * - freeing the memory allocated for E2nodeConfigurationUpdate
5654 * @params[in] E2AP_PDU_t *e2apMsg
5655 * @return ROK - success
5658 * ****************************************************************/
5660 void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
5662 uint8_t arrIdx =0, e2NodeConfigIdx=0;
5663 E2nodeConfigurationUpdateAcknowledge_t *updateAckMsg=NULL;
5664 E2nodeComponentConfigUpdateAck_ItemIEs_t *updateAckItemIe=NULL;
5665 E2nodeComponentConfigUpdateAck_List_t *updateAckList=NULL;
5666 E2nodeComponentConfigRemovalAck_ItemIEs_t *removalAckItemIe=NULL;
5667 E2nodeComponentConfigRemovalAck_List_t *removalAckList=NULL;
5668 E2nodeComponentConfigAdditionAck_ItemIEs_t *additionAckItemIte=NULL;
5669 E2nodeComponentConfigAdditionAck_List_t *additionAckList=NULL;
5671 if(e2apMsg != NULLP)
5673 if(e2apMsg->choice.successfulOutcome != NULLP)
5675 updateAckMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
5676 if(updateAckMsg->protocolIEs.list.array != NULLP)
5678 for(arrIdx = 0; arrIdx < updateAckMsg->protocolIEs.list.count; arrIdx++)
5680 if(updateAckMsg->protocolIEs.list.array[arrIdx])
5682 switch(updateAckMsg->protocolIEs.list.array[arrIdx]->id)
5684 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
5686 additionAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
5687 if(additionAckList->list.array)
5689 for(e2NodeConfigIdx=0; e2NodeConfigIdx<additionAckList->list.count; e2NodeConfigIdx++)
5691 additionAckItemIte = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) additionAckList->list.array[e2NodeConfigIdx];
5692 if(additionAckItemIte)
5694 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck,\
5695 (PTR)&additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item);
5696 RIC_FREE(additionAckItemIte, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
5699 RIC_FREE(additionAckList->list.array, additionAckList->list.size);
5703 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
5705 updateAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
5706 if(updateAckList->list.array)
5708 for(e2NodeConfigIdx=0; e2NodeConfigIdx<updateAckList->list.count; e2NodeConfigIdx++)
5710 updateAckItemIe = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) updateAckList->list.array[e2NodeConfigIdx];
5713 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck,\
5714 (PTR)&updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item);
5715 RIC_FREE(updateAckItemIe, sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t));
5718 RIC_FREE(updateAckList->list.array, updateAckList->list.size);
5722 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
5724 removalAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
5725 if(removalAckList->list.array)
5727 for(e2NodeConfigIdx=0; e2NodeConfigIdx<removalAckList->list.count; e2NodeConfigIdx++)
5729 removalAckItemIe = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) removalAckList->list.array[e2NodeConfigIdx];
5730 if(removalAckItemIe)
5732 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck,\
5733 (PTR)&removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item);
5734 RIC_FREE(removalAckItemIe, sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t));
5737 RIC_FREE(removalAckList->list.array, removalAckList->list.size);
5742 RIC_FREE(updateAckMsg->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
5745 RIC_FREE(updateAckMsg->protocolIEs.list.array, updateAckMsg->protocolIEs.list.size);
5747 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
5749 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5753 /*******************************************************************
5755 * @brief Build E2node Component config Removal ack list
5759 * Function : BuildE2nodeComponentConfigRemovalAck
5761 * Functionality: Build the e2 node remove ack
5764 * E2nodeComponentConfigRemovalAck_List_t to be filled
5765 * Count of e2 node to be removed
5766 * list of e2 node cfg to be removed
5768 * @return ROK - success
5770 * ****************************************************************/
5772 uint8_t BuildE2nodeComponentConfigRemovalAck(E2nodeComponentConfigRemovalAck_List_t *e2NodeConfigRemovalAckList,\
5773 uint16_t removalE2NodeCount, E2NodeConfigItem *removaldE2Node)
5776 E2nodeComponentConfigRemovalAck_ItemIEs_t *e2NodeRemovalAckItem=NULL;
5778 /* Filling the e2 node config removal ack list */
5779 e2NodeConfigRemovalAckList->list.count = removalE2NodeCount;
5780 e2NodeConfigRemovalAckList->list.size = e2NodeConfigRemovalAckList->list.count * sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t*);
5781 RIC_ALLOC(e2NodeConfigRemovalAckList->list.array, e2NodeConfigRemovalAckList->list.size);
5782 if(e2NodeConfigRemovalAckList->list.array == NULLP)
5784 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
5788 for(arrIdx = 0; arrIdx< e2NodeConfigRemovalAckList->list.count; arrIdx++)
5790 RIC_ALLOC(e2NodeConfigRemovalAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t));
5791 if(e2NodeConfigRemovalAckList->list.array[arrIdx] == NULLP)
5793 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
5796 e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[arrIdx];
5797 e2NodeRemovalAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck_Item;
5798 e2NodeRemovalAckItem->criticality = CriticalityE2_reject;
5799 e2NodeRemovalAckItem->value.present = E2nodeComponentConfigRemovalAck_ItemIEs__value_PR_E2nodeComponentConfigRemovalAck_Item;
5801 /* Filling the e2 node config removal ack item */
5802 fillE2NodeConfigAck((PTR)&e2NodeRemovalAckItem->value.choice.E2nodeComponentConfigRemovalAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck,\
5803 &removaldE2Node[arrIdx].componentInfo, removaldE2Node[arrIdx].isSuccessful);
5808 /*******************************************************************
5810 * @brief Build E2node Component config update ack list
5814 * Function : BuildE2nodeComponentConfigUpdateAck
5816 * Functionality: Build E2node Component config update ack list
5819 * E2nodeComponentConfigUpdateAck_List to be filled
5820 * Count of e2 node to be update
5821 * list of e2 node cfg to be update
5823 * @return ROK - success
5825 * ****************************************************************/
5827 uint8_t BuildE2nodeComponentConfigUpdateAck(E2nodeComponentConfigUpdateAck_List_t *e2NodeConfigUpdateAckList,\
5828 uint16_t updatedE2NodeCount, E2NodeConfigItem *updatedE2Node)
5831 E2nodeComponentConfigUpdateAck_ItemIEs_t *e2NodeUpdateAckItem=NULL;
5833 /* Filling the e2 node config update ack list */
5834 e2NodeConfigUpdateAckList->list.count = updatedE2NodeCount;
5835 e2NodeConfigUpdateAckList->list.size = e2NodeConfigUpdateAckList->list.count * sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t*);
5836 RIC_ALLOC(e2NodeConfigUpdateAckList->list.array, e2NodeConfigUpdateAckList->list.size);
5837 if(e2NodeConfigUpdateAckList->list.array == NULLP)
5839 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
5843 for(arrIdx = 0; arrIdx< e2NodeConfigUpdateAckList->list.count; arrIdx++)
5845 RIC_ALLOC(e2NodeConfigUpdateAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t));
5846 if(e2NodeConfigUpdateAckList->list.array[arrIdx] == NULLP)
5848 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
5851 e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[arrIdx];
5852 e2NodeUpdateAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck_Item;
5853 e2NodeUpdateAckItem->criticality = CriticalityE2_reject;
5854 e2NodeUpdateAckItem->value.present = E2nodeComponentConfigUpdateAck_ItemIEs__value_PR_E2nodeComponentConfigUpdateAck_Item;
5856 /* Filling the e2 node config update ack item */
5857 fillE2NodeConfigAck((PTR)&e2NodeUpdateAckItem->value.choice.E2nodeComponentConfigUpdateAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck,\
5858 &updatedE2Node[arrIdx].componentInfo, updatedE2Node[arrIdx].isSuccessful);
5864 /*******************************************************************
5866 * @brief Buld and send the E2 node config update ack msg
5870 * Function : BuildAndSendE2NodeConfigUpdateAck
5873 * - Buld and send the E2 node config update ack msg
5877 * list of E2 node cfg which needs to fill in IEs
5878 * @return ROK - success
5881 * ****************************************************************/
5883 uint8_t BuildAndSendE2NodeConfigUpdateAck(DuDb *duDb, uint8_t transId, E2NodeConfigList *e2NodeList)
5885 uint8_t ret = RFAILED;
5886 uint8_t arrIdx = 0,elementCnt = 0;
5887 E2AP_PDU_t *e2apMsg = NULLP;
5888 asn_enc_rval_t encRetVal;
5889 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
5891 DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
5894 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5895 if(e2apMsg == NULLP)
5897 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5900 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
5901 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
5902 if(e2apMsg->choice.successfulOutcome == NULLP)
5904 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5908 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
5909 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
5910 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
5911 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
5914 if(e2NodeList->addedE2NodeCount)
5916 if(e2NodeList->updatedE2NodeCount)
5918 if(e2NodeList->removedE2NodeCount)
5921 e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
5922 e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
5923 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
5924 if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
5926 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5930 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
5932 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
5933 if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
5936 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5941 if(arrIdx<elementCnt)
5945 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5946 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5947 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
5948 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5950 if(e2NodeList->addedE2NodeCount)
5953 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
5954 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5955 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigAdditionAck_List;
5956 if(BuildE2nodeComponentConfigAdditionAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List,\
5957 e2NodeList->addedE2NodeCount, e2NodeList->addedE2Node)!=ROK)
5960 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
5964 if(e2NodeList->updatedE2NodeCount)
5967 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck;
5968 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5969 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigUpdateAck_List;
5970 if(BuildE2nodeComponentConfigUpdateAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List,\
5971 e2NodeList->updatedE2NodeCount, e2NodeList->updatedE2Node)!=ROK)
5974 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config update ack list");
5978 if(e2NodeList->removedE2NodeCount)
5981 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck;
5982 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5983 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigRemovalAck_List;
5984 if(BuildE2nodeComponentConfigRemovalAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List,\
5985 e2NodeList->removedE2NodeCount, e2NodeList->removedE2Node)!=ROK)
5988 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config removal ack list");
5992 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5994 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5996 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
5998 if(encRetVal.encoded == ENCODE_FAIL)
6000 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
6001 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6006 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
6007 for(int i=0; i< encBufSize; i++)
6009 DU_LOG("%x",encBuf[i]);
6015 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
6017 DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
6024 FreeE2NodeConfigUpdateAck(e2apMsg);
6029 /******************************************************************
6031 * @brief Processes the E2 removal failure msg
6035 * Function : procE2RemovalFailure
6037 * Functionality: Processes the E2 removal failure msg
6040 * E2 Removal Failure information
6044 * ****************************************************************/
6045 void ProcE2RemovalFailure(E2RemovalFailure_t *e2RemovalFailure)
6047 uint8_t ieIdx = 0, transId=0;
6048 CauseE2_t *cause = NULLP;
6050 if(!e2RemovalFailure)
6052 DU_LOG("\nERROR --> E2AP : e2RemovalFailure pointer is null");
6056 if(!e2RemovalFailure->protocolIEs.list.array)
6058 DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
6062 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
6064 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
6066 switch(e2RemovalFailure->protocolIEs.list.array[ieIdx]->id)
6068 case ProtocolIE_IDE2_id_TransactionID:
6070 transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
6071 DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
6074 case ProtocolIE_IDE2_id_CauseE2:
6076 cause = &e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
6077 printE2ErrorCause(cause);
6082 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%d]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
6089 /*******************************************************************
6091 * @brief Delete E2 component node list
6095 * Function : deleteE2ComponentNodeList
6097 * Functionality: Delete E2 component node list
6099 * @params[in] E2 component node list
6103 ******************************************************************/
6105 void deleteE2ComponentNodeList(CmLListCp *componentList)
6107 E2NodeComponent *cfgInfo = NULLP;
6108 CmLList *e2ComponentNode = NULLP;
6110 CM_LLIST_FIRST_NODE(componentList, e2ComponentNode);
6111 while(e2ComponentNode)
6113 cfgInfo = (E2NodeComponent*)e2ComponentNode->node;
6114 cmLListDelFrm(componentList, e2ComponentNode);
6115 memset(cfgInfo, 0, sizeof(E2NodeComponent));
6116 CM_LLIST_FIRST_NODE(componentList, e2ComponentNode);
6120 /*******************************************************************
6122 * @brief process the E2 node information from ric db
6126 * Function : deleteE2NodeInfo
6128 * Functionality: process the E2 node information from ric db
6135 ******************************************************************/
6136 void deleteE2NodeInfo(DuDb *duDb)
6138 uint16_t ranFuncIdx =0;
6139 RanFunction *ranFuncDb=NULLP;
6141 DU_LOG("\nINFO --> E2AP : Removing all the E2 node information");
6142 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
6144 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
6145 if(ranFuncDb->id > 0)
6147 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
6150 deleteE2ComponentNodeList(&duDb->e2NodeComponent);
6153 /*******************************************************************
6155 * @brief process the E2 Removal Response
6159 * Function : ProcE2RemovalResponse
6161 * Functionality: Process E2 Removal Response
6165 * Pointer to removal response
6168 ******************************************************************/
6170 void ProcE2RemovalResponse(uint32_t duId, E2RemovalResponse_t *removalRsp)
6172 uint8_t ieIdx = 0, duIdx =0;
6175 SEARCH_DU_DB(duIdx, duId, duDb);
6178 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6184 DU_LOG("\nERROR --> E2AP : removalRsp pointer is null");
6188 if(!removalRsp->protocolIEs.list.array)
6190 DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
6194 for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
6196 if(removalRsp->protocolIEs.list.array[ieIdx])
6198 switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
6200 case ProtocolIE_IDE2_id_TransactionID:
6202 DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
6203 cmInetClose(&sctpCb.e2LstnSockFd);
6204 deleteE2NodeInfo(duDb);
6209 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
6216 /*******************************************************************
6218 * @brief Deallocate the memory allocated for E2 Removal Failure
6222 * Function : FreeE2RemovalFailure
6225 * - freeing the memory allocated for E2RemovalFailure
6227 * @params[in] E2AP_PDU_t *e2apMsg
6230 * ****************************************************************/
6231 void FreeE2RemovalFailure(E2AP_PDU_t *e2apMsg)
6234 E2RemovalFailure_t *e2RemovalFailure=NULLP;
6236 if(e2apMsg != NULLP)
6238 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
6240 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
6241 if(e2RemovalFailure->protocolIEs.list.array)
6243 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
6245 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
6247 RIC_FREE(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
6250 RIC_FREE(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
6252 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
6254 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6258 /*******************************************************************
6260 * @brief Buld and send the E2 Removal Failure msg
6264 * Function : BuildAndSendE2RemovalFailure
6267 * - Buld and send the E2 Removal Failure Message
6273 * @return ROK - success
6276 * ****************************************************************/
6278 uint8_t BuildAndSendRemovalFailure(uint32_t duId, uint16_t transId, CauseE2_PR causePresent, uint8_t reason)
6280 uint8_t ieIdx = 0, elementCnt = 0;
6281 uint8_t ret = RFAILED;
6282 E2AP_PDU_t *e2apMsg = NULLP;
6283 E2RemovalFailure_t *e2RemovalFailure=NULLP;
6284 asn_enc_rval_t encRetVal; /* Encoder return value */
6286 DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
6289 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6290 if(e2apMsg == NULLP)
6292 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6295 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
6297 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
6298 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
6300 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6304 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
6305 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
6306 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure;
6307 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
6310 e2RemovalFailure->protocolIEs.list.count = elementCnt;
6311 e2RemovalFailure->protocolIEs.list.size = elementCnt * sizeof(E2RemovalFailureIEs_t *);
6312 RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
6313 if(!e2RemovalFailure->protocolIEs.list.array)
6315 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6319 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6321 RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
6322 if(!e2RemovalFailure->protocolIEs.list.array[ieIdx])
6324 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6328 if(ieIdx < elementCnt)
6332 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6333 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6334 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = E2RemovalFailureIEs__value_PR_TransactionID;
6335 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
6339 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
6340 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
6341 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
6342 fillE2FailureCause(&e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
6344 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6346 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6348 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6349 if(encRetVal.encoded == ENCODE_FAIL)
6351 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
6352 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6357 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
6358 for(int i=0; i< encBufSize; i++)
6360 DU_LOG("%x",encBuf[i]);
6365 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6367 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Failure");
6375 FreeE2RemovalFailure(e2apMsg);
6379 /*******************************************************************
6381 * @brief Deallocate the memory allocated for E2 Removal Response
6385 * Function : FreeE2RemovalResponse
6388 * - freeing the memory allocated for E2RemovalResponse
6390 * @params[in] E2AP_PDU_t *e2apMsg
6391 * @return ROK - success
6394 * ****************************************************************/
6395 void FreeE2RemovalResponse(E2AP_PDU_t *e2apMsg)
6398 E2RemovalResponse_t *e2RemovalResponse=NULLP;
6400 if(e2apMsg != NULLP)
6402 if(e2apMsg->choice.successfulOutcome != NULLP)
6404 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
6405 if(e2RemovalResponse->protocolIEs.list.array)
6407 for(ieIdx=0; ieIdx < e2RemovalResponse->protocolIEs.list.count; ieIdx++)
6409 if(e2RemovalResponse->protocolIEs.list.array[ieIdx])
6411 RIC_FREE(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
6414 RIC_FREE(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
6416 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6418 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6422 /*******************************************************************
6424 * @brief Buld and send the E2 Removal Response msg
6428 * Function : BuildAndSendE2RemovalResponse
6431 * - Buld and send the E2 Removal Response Message
6435 * @return ROK - success
6438 * ****************************************************************/
6439 uint8_t BuildAndSendRemovalResponse(uint32_t duId, uint16_t transId)
6441 uint8_t ieIdx = 0, elementCnt = 0;
6442 uint8_t ret = RFAILED, duIdx =0;
6443 E2AP_PDU_t *e2apMsg = NULLP;
6445 E2RemovalResponse_t *e2RemovalResponse=NULLP;
6446 asn_enc_rval_t encRetVal; /* Encoder return value */
6448 DU_LOG("\nINFO --> E2AP : Building E2 Removal Response Message\n");
6451 SEARCH_DU_DB(duIdx, duId, duDb);
6454 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6458 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6459 if(e2apMsg == NULLP)
6461 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6464 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
6466 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6467 if(e2apMsg->choice.successfulOutcome == NULLP)
6469 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6473 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
6474 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
6475 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2RemovalResponse;
6476 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
6479 e2RemovalResponse->protocolIEs.list.count = elementCnt;
6480 e2RemovalResponse->protocolIEs.list.size = elementCnt * sizeof(E2RemovalResponseIEs_t *);
6481 RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
6482 if(!e2RemovalResponse->protocolIEs.list.array)
6484 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6488 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6490 RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
6491 if(!e2RemovalResponse->protocolIEs.list.array[ieIdx])
6493 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6497 if(ieIdx < elementCnt)
6501 e2RemovalResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6502 e2RemovalResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6503 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.present = E2RemovalResponseIEs__value_PR_TransactionID;
6504 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
6506 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6508 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6510 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6511 if(encRetVal.encoded == ENCODE_FAIL)
6513 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
6514 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6519 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
6520 for(int i=0; i< encBufSize; i++)
6522 DU_LOG("%x",encBuf[i]);
6527 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6529 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Response");
6537 FreeE2RemovalResponse(e2apMsg);
6541 /*******************************************************************
6543 * @brief Process Removal req received from RIC
6547 * Function : procE2RemovalRequest
6549 * Functionality: Process Removal req received from RIC
6553 * E2 Removal Request
6556 ******************************************************************/
6558 void procE2RemovalRequest(uint32_t duId, E2RemovalRequest_t *removalReq)
6561 uint16_t transId =0;
6563 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
6565 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
6567 switch(removalReq->protocolIEs.list.array[arrIdx]->id)
6569 case ProtocolIE_IDE2_id_TransactionID:
6571 transId = removalReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
6576 DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
6582 if(transId>=0 && transId<=255)
6584 if(BuildAndSendRemovalResponse(duId, transId) != ROK)
6586 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
6591 if(BuildAndSendRemovalFailure(duId, transId, CauseE2_PR_protocol, CauseE2Protocol_abstract_syntax_error_falsely_constructed_message) != ROK)
6593 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
6598 /*******************************************************************
6600 * @brief fill E2 connection update item
6604 * Function : fillE2connectionUpdateItem
6606 * Functionality: fill E2 connection update item
6609 * E2connectionUpdate Item to be filled
6611 * @return ROK - success
6613 * ****************************************************************/
6615 uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId)
6617 E2connectionUpdateRemove_Item_t *connectionRemoveITem=NULLP;
6618 E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
6619 TNLinformation_t *tnlInformation = NULLP;
6620 TNLusage_t *tnlUsage=NULLP;
6624 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
6626 connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
6627 tnlInformation = &connectionModifyItem->tnlInformation;
6628 tnlUsage = &connectionModifyItem->tnlUsage;
6632 case ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item:
6634 connectionRemoveITem = (E2connectionUpdateRemove_Item_t*)connectionInfo;
6635 tnlInformation= &connectionRemoveITem->tnlInformation;
6640 tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
6641 RIC_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
6642 if(!tnlInformation->tnlAddress.buf)
6644 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6648 tnlInformation->tnlAddress.buf[3] = ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr & 0xFF;
6649 tnlInformation->tnlAddress.buf[2] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 8) & 0xFF;
6650 tnlInformation->tnlAddress.buf[1] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 16) & 0xFF;
6651 tnlInformation->tnlAddress.buf[0] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 24) & 0xFF;
6652 tnlInformation->tnlAddress.bits_unused = 0;
6653 if(protocolId == ProtocolIE_IDE2_id_E2connectionUpdate_Item)
6655 *tnlUsage = TNLusage_support_function;
6660 /*******************************************************************
6662 * @brief Build E2 connection modification list
6666 * Function : BuildE2ConnectionModifyList
6668 * Functionality: Build E2 connection modification list
6671 * E2 connection modification list to be filled
6673 * @return ROK - success
6675 * ****************************************************************/
6677 uint8_t BuildE2ConnectionModifyList(E2connectionUpdate_List_t *connectionToBeModifyList)
6680 E2connectionUpdate_ItemIEs_t *connectionModify=NULL;
6682 connectionToBeModifyList->list.count = 1;
6684 connectionToBeModifyList->list.size = connectionToBeModifyList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
6685 RIC_ALLOC(connectionToBeModifyList->list.array, connectionToBeModifyList->list.size);
6686 if(connectionToBeModifyList->list.array)
6688 for(arrIdx = 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
6690 RIC_ALLOC(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
6691 if(connectionToBeModifyList->list.array[arrIdx] == NULLP)
6693 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6696 connectionModify = (E2connectionUpdate_ItemIEs_t*)connectionToBeModifyList->list.array[arrIdx];
6697 connectionModify->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
6698 connectionModify->criticality= CriticalityE2_ignore;
6699 connectionModify->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
6700 if(fillE2connectionUpdateItem((PTR)&connectionModify->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item) != ROK)
6702 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
6710 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6716 /*******************************************************************
6718 * @brief Build E2 connection remove list
6722 * Function : BuildE2ConnectionRemoveList
6724 * Functionality: Build E2 connection remove list
6727 * E2 connection remove list to be filled
6729 * @return ROK - success
6731 * ****************************************************************/
6733 uint8_t BuildE2ConnectionRemoveList(E2connectionUpdateRemove_List_t *connectionToBeRemoveList)
6736 E2connectionUpdateRemove_ItemIEs_t *connectionRemove=NULL;
6738 connectionToBeRemoveList->list.count = 1;
6740 connectionToBeRemoveList->list.size = connectionToBeRemoveList->list.count*sizeof(E2connectionUpdateRemove_ItemIEs_t*);
6741 RIC_ALLOC(connectionToBeRemoveList->list.array, connectionToBeRemoveList->list.size);
6742 if(connectionToBeRemoveList->list.array)
6744 for(arrIdx = 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
6746 RIC_ALLOC(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
6747 if(connectionToBeRemoveList->list.array[arrIdx] == NULLP)
6749 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6752 connectionRemove = (E2connectionUpdateRemove_ItemIEs_t*)connectionToBeRemoveList->list.array[arrIdx];
6753 connectionRemove->id = ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item;
6754 connectionRemove->criticality= CriticalityE2_ignore;
6755 connectionRemove->value.present = E2connectionUpdateRemove_ItemIEs__value_PR_E2connectionUpdateRemove_Item;
6756 if(fillE2connectionUpdateItem((PTR)&connectionRemove->value.choice.E2connectionUpdateRemove_Item, ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item) != ROK)
6758 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
6766 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6772 /*******************************************************************
6774 * @brief Deallocate the memory allocated for E2ConnectionUpdate msg
6778 * Function : FreeE2ConnectionUpdate
6781 * - freeing the memory allocated for E2ConnectionUpdate
6783 * @params[in] E2AP_PDU_t *e2apMsg
6784 * @return ROK - success
6787 * ****************************************************************/
6788 void FreeE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
6790 uint8_t ieIdx =0, arrIdx=0;
6791 E2connectionUpdate_t *connectionUpdate = NULLP;
6792 E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
6793 E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
6795 if(e2apMsg != NULLP)
6797 if(e2apMsg->choice.initiatingMessage != NULLP)
6799 connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
6800 if(connectionUpdate->protocolIEs.list.array)
6802 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
6804 if(connectionUpdate->protocolIEs.list.array[ieIdx])
6806 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
6808 case ProtocolIE_IDE2_id_TransactionID:
6811 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
6813 connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
6814 if(connectionToBeModifyList->list.array)
6816 for(arrIdx = 0; arrIdx < connectionToBeModifyList->list.count; arrIdx++)
6818 RIC_FREE(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
6820 RIC_FREE(connectionToBeModifyList->list.array, connectionToBeModifyList->list.size);
6825 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
6827 connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
6828 if(connectionToBeRemoveList->list.array)
6830 for(arrIdx = 0; arrIdx < connectionToBeRemoveList->list.count; arrIdx++)
6832 RIC_FREE(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
6834 RIC_FREE(connectionToBeRemoveList->list.array, connectionToBeRemoveList->list.size);
6839 RIC_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
6842 RIC_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
6844 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6846 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6850 /*******************************************************************
6852 * @brief Buld and send the E2 Connection Update msg
6856 * Function : BuildAndSendE2ConnectionUpdate
6859 * - Buld and send the E2 Connection Update Message
6862 * E2 connection to be modify or delete
6863 * @return ROK - success
6866 * ****************************************************************/
6868 uint8_t BuildAndSendE2ConnectionUpdate(uint32_t duId, E2Connection connectionInfo)
6870 uint8_t ieIdx = 0, elementCnt = 0;
6871 uint8_t ret = RFAILED, duIdx =0;
6873 E2AP_PDU_t *e2apMsg = NULLP;
6874 E2connectionUpdate_t *e2ConnectionUpdate=NULLP;
6875 asn_enc_rval_t encRetVal; /* Encoder return value */
6877 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Message\n");
6880 SEARCH_DU_DB(duIdx, duId, duDb);
6883 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6887 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6888 if(e2apMsg == NULLP)
6890 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6893 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6895 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6896 if(e2apMsg->choice.initiatingMessage == NULLP)
6898 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6902 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
6903 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6904 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2connectionUpdate;
6905 e2ConnectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
6908 if(connectionInfo == MODIFY_CONNECTION)
6910 if(connectionInfo == REMOVE_CONNECTION)
6913 e2ConnectionUpdate->protocolIEs.list.count = elementCnt;
6914 e2ConnectionUpdate->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdate_IEs_t*);
6915 RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array, e2ConnectionUpdate->protocolIEs.list.size);
6916 if(!e2ConnectionUpdate->protocolIEs.list.array)
6918 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6922 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6924 RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
6925 if(!e2ConnectionUpdate->protocolIEs.list.array[ieIdx])
6927 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6931 if(ieIdx < elementCnt)
6935 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6936 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6937 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_TransactionID;
6938 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = assignTransactionId(duDb);
6940 if(connectionInfo == MODIFY_CONNECTION)
6943 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionUpdateModify;
6944 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6945 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdate_List;
6946 if(BuildE2ConnectionModifyList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List) != ROK)
6948 DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
6953 if(connectionInfo == REMOVE_CONNECTION)
6956 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionUpdateRemove;
6957 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6958 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdateRemove_List;
6959 if(BuildE2ConnectionRemoveList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List) != ROK)
6961 DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
6966 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6968 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6970 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6971 if(encRetVal.encoded == ENCODE_FAIL)
6973 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update structure (at %s)\n",\
6974 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6979 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update \n");
6980 for(int i=0; i< encBufSize; i++)
6982 DU_LOG("%x",encBuf[i]);
6987 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6989 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update");
6997 FreeE2ConnectionUpdate(e2apMsg);
7001 /******************************************************************
7003 * @brief Processes the E2 connection update failure msg
7007 * Function : procE2connectionUpdateFailure
7009 * Functionality: Processes the E2 connection update failure msg
7012 * E2 connection update failure information
7016 * ****************************************************************/
7017 void ProcE2connectionUpdateFailure(E2connectionUpdateFailure_t *updateFailure)
7021 CauseE2_t *cause = NULLP;
7025 DU_LOG("\nERROR --> E2AP : updateFailure pointer is null");
7029 if(!updateFailure->protocolIEs.list.array)
7031 DU_LOG("\nERROR --> E2AP : updateFailure array pointer is null");
7035 for(ieIdx=0; ieIdx < updateFailure->protocolIEs.list.count; ieIdx++)
7037 if(updateFailure->protocolIEs.list.array[ieIdx])
7039 switch(updateFailure->protocolIEs.list.array[ieIdx]->id)
7041 case ProtocolIE_IDE2_id_TransactionID:
7043 transId = updateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
7044 DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
7047 case ProtocolIE_IDE2_id_CauseE2:
7049 cause = &updateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
7050 printE2ErrorCause(cause);
7055 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%d]", updateFailure->protocolIEs.list.array[ieIdx]->id);
7063 /*******************************************************************
7065 * @brief process the E2 Connection update ack
7069 * Function : ProcE2ConnectionUpdateAck
7071 * Functionality: Process E2 Connection update ack
7075 * Pointer to Connection update ack
7078 ******************************************************************/
7080 void ProcE2ConnectionUpdateAck(uint32_t duId, E2connectionUpdateAcknowledge_t *connectionUpdateAck)
7082 uint16_t transId =0;
7083 uint32_t ipAddress=0;
7085 uint8_t ieIdx = 0, duIdx =0, arrIdx=0;
7086 E2connectionUpdate_Item_t *connectionSetupItem=NULLP;
7087 E2connectionUpdate_ItemIEs_t *connectionSetupItemIe=NULLP;
7088 E2connectionUpdate_List_t *connectionSetupList=NULLP;
7089 E2connectionSetupFailed_Item_t *setupFailedItem =NULLP;
7090 E2connectionSetupFailed_List_t *setupFailedList=NULLP;
7091 E2connectionSetupFailed_ItemIEs_t *setupFailedItemIe =NULLP;
7093 SEARCH_DU_DB(duIdx, duId, duDb);
7096 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
7100 if(!connectionUpdateAck)
7102 DU_LOG("\nERROR --> E2AP : connectionUpdateAck pointer is null");
7106 if(!connectionUpdateAck->protocolIEs.list.array)
7108 DU_LOG("\nERROR --> E2AP : connectionUpdateAck array pointer is null");
7112 for(ieIdx=0; ieIdx < connectionUpdateAck->protocolIEs.list.count; ieIdx++)
7114 if(connectionUpdateAck->protocolIEs.list.array[ieIdx])
7116 switch(connectionUpdateAck->protocolIEs.list.array[ieIdx]->id)
7118 case ProtocolIE_IDE2_id_TransactionID:
7120 transId = connectionUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
7123 DU_LOG("\nERROR --> E2AP : Received invalid trans id %d ",transId);
7128 case ProtocolIE_IDE2_id_E2connectionSetup:
7130 connectionSetupList=&connectionUpdateAck->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
7131 if(connectionSetupList->list.array)
7133 for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
7135 connectionSetupItemIe = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
7136 connectionSetupItem = &connectionSetupItemIe->value.choice.E2connectionUpdate_Item;
7137 bitStringToInt(&connectionSetupItem->tnlInformation.tnlAddress, &ipAddress);
7138 if(ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr == ipAddress)
7140 ricCb.ricCfgParams.sctpParams.usage = connectionSetupItem->tnlUsage;
7147 case ProtocolIE_IDE2_id_E2connectionSetupFailed:
7149 setupFailedList=&connectionUpdateAck->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
7150 if(setupFailedList->list.array)
7152 for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
7154 setupFailedItemIe = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
7155 setupFailedItem = &setupFailedItemIe->value.choice.E2connectionSetupFailed_Item;
7156 printE2ErrorCause(&setupFailedItem->cause);
7163 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", connectionUpdateAck->protocolIEs.list.array[ieIdx]->id);
7171 /******************************************************************
7173 * @brief Processes the Ric Subs delete failure msg
7177 * Function : procRicSubsDeleteFailure
7179 * Functionality: Processes the Ric Subs delete failure msg
7182 * Ric Subs delete failure information
7186 * ****************************************************************/
7187 void ProcRicSubsDeleteFailure(RICsubscriptionDeleteFailure_t *ricSubsDeleteFail)
7190 uint16_t ranFuncId=0;
7191 CauseE2_t *cause = NULLP;
7192 RICrequestID_t ricRequestID;
7194 if(!ricSubsDeleteFail)
7196 DU_LOG("\nERROR --> E2AP : ricSubsDeleteFail pointer is null");
7200 if(!ricSubsDeleteFail->protocolIEs.list.array)
7202 DU_LOG("\nERROR --> E2AP : ricSubsDeleteFail array pointer is null");
7206 for(ieIdx=0; ieIdx < ricSubsDeleteFail->protocolIEs.list.count; ieIdx++)
7208 if(ricSubsDeleteFail->protocolIEs.list.array[ieIdx])
7210 switch(ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->id)
7212 case ProtocolIE_IDE2_id_RICrequestID:
7214 memcpy(&ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t));
7215 DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
7218 case ProtocolIE_IDE2_id_RANfunctionID:
7220 ranFuncId = ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
7221 DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId);
7224 case ProtocolIE_IDE2_id_CauseE2:
7226 cause = &ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
7227 printE2ErrorCause(cause);
7232 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->id);
7241 /******************************************************************
7243 * @brief Processes the Ric Subs delete rsp msg
7247 * Function : ProcRicSubsDeleteRsp
7249 * Functionality: Processes the Ric Subs delete rsp msg
7252 * Ric Subs delete rsp information
7256 * ****************************************************************/
7257 void ProcRicSubsDeleteRsp(uint32_t duId, RICsubscriptionDeleteResponse_t *ricSubsDeleteRsp)
7261 uint16_t ranFuncId=0;
7262 RanFunction *ranFuncDb = NULLP;
7263 RicRequestId ricReqId;
7265 RicSubscription *ricSubs = NULLP;
7266 CmLList *ricSubsNode = NULLP;
7268 SEARCH_DU_DB(duIdx, duId, duDb);
7271 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
7275 if(!ricSubsDeleteRsp)
7277 DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp pointer is null");
7281 if(!ricSubsDeleteRsp->protocolIEs.list.array)
7283 DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp array pointer is null");
7286 for(ieIdx=0; ieIdx < ricSubsDeleteRsp->protocolIEs.list.count; ieIdx++)
7288 if(ricSubsDeleteRsp->protocolIEs.list.array[ieIdx])
7290 switch(ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->id)
7292 case ProtocolIE_IDE2_id_RICrequestID:
7294 ricReqId.requestorId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricRequestorID;
7295 ricReqId.instanceId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricInstanceID;
7298 case ProtocolIE_IDE2_id_RANfunctionID:
7300 ranFuncId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
7301 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
7304 DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
7308 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
7311 deleteRicSubscriptionNode(ricSubsNode);
7312 DU_LOG("\nINFO --> E2AP : Ric subscription node deleted successfully");
7316 DU_LOG("\nERROR --> E2AP : Ric subscription node is not present ");
7327 /******************************************************************
7329 * @brief Processes the Ric Subs modification failure msg
7333 * Function : procRicSubsModificationFailure
7335 * Functionality: Processes the Ric Subs modification failure msg
7338 * Ric Subs modification failure information
7342 * ****************************************************************/
7343 void ProcRicSubsModificationFailure(RICsubscriptionModificationFailure_t *ricSubsModificationFail)
7346 uint16_t ranFuncId=0;
7347 CauseE2_t *cause = NULLP;
7348 RICrequestID_t ricRequestID;
7350 DU_LOG("\nINFO --> E2AP : Ric subscription modification failure received");
7352 if(!ricSubsModificationFail)
7354 DU_LOG("\nERROR --> E2AP : ricSubsModificationFail pointer is null");
7358 if(!ricSubsModificationFail->protocolIEs.list.array)
7360 DU_LOG("\nERROR --> E2AP : ricSubsModificationFail array pointer is null");
7364 for(ieIdx=0; ieIdx < ricSubsModificationFail->protocolIEs.list.count; ieIdx++)
7366 if(ricSubsModificationFail->protocolIEs.list.array[ieIdx])
7368 switch(ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id)
7370 case ProtocolIE_IDE2_id_RICrequestID:
7372 memcpy(&ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t));
7373 DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
7376 case ProtocolIE_IDE2_id_RANfunctionID:
7378 ranFuncId = ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
7379 DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId);
7382 case ProtocolIE_IDE2_id_CauseE2:
7384 cause = &ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
7385 printE2ErrorCause(cause);
7390 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id);
7398 /*******************************************************************
7400 * @brief Free RIC Subscription action to be added list
7404 * Function : FreeRicSubsActionToBeAdded
7406 * Functionality: Free the RIC Subscription action to be added list
7408 * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
7411 * ****************************************************************/
7412 void FreeRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
7414 uint8_t elementIdx = 0;
7415 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
7417 if(subsDetails->list.array)
7419 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
7421 if(subsDetails->list.array[elementIdx])
7423 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
7424 RIC_FREE(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf, \
7425 addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.size);
7426 RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t));
7429 RIC_FREE(subsDetails->list.array, subsDetails->list.size);
7433 /*******************************************************************
7435 * @brief Free RIC Subscription action to be removed list
7439 * Function : FreeRicSubsActionToBeRemoved
7441 * Functionality: Free the RIC Subscription action to be removed list
7443 * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
7446 * ****************************************************************/
7447 void FreeRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
7449 uint8_t elementIdx = 0;
7451 if(subsDetails->list.array)
7453 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
7455 RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t));
7457 RIC_FREE(subsDetails->list.array, subsDetails->list.size);
7461 /*******************************************************************
7463 * @brief Free RIC Subscription action to be modify
7467 * Function : FreeRicSubsActionToBeModified
7469 * Functionality: Free the RIC Subscription action to be modify
7471 * @params[in] RICactions_ToBeModifiedForModification_List_t List
7474 * ****************************************************************/
7475 void FreeRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
7477 uint8_t elementIdx = 0;
7478 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
7480 if(subsDetails->list.array)
7482 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
7484 if(subsDetails->list.array[elementIdx])
7486 actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx];
7487 if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
7489 RIC_FREE(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf, \
7490 actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->size);
7491 RIC_FREE(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
7493 RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t))
7496 RIC_FREE(subsDetails->list.array, subsDetails->list.size);
7500 /*******************************************************************
7502 * @brief Free RIC Subscription modification Request
7506 * Function :FreeRicSubscriptionModReq
7508 * Functionality : Free RIC Subscription modification Request
7510 * @params[in] E2AP_PDU
7513 ******************************************************************/
7514 void FreeRicSubscriptionModReq(E2AP_PDU_t *e2apRicMsg)
7517 RICsubscriptionModificationRequest_t *ricSubscriptionModReq =NULLP;
7518 RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe=NULLP;
7522 if(e2apRicMsg->choice.initiatingMessage)
7524 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
7525 if(ricSubscriptionModReq->protocolIEs.list.array)
7527 for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
7529 if(ricSubscriptionModReq->protocolIEs.list.array[idx])
7531 ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
7532 switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
7534 case ProtocolIE_IDE2_id_RICrequestID:
7536 case ProtocolIE_IDE2_id_RANfunctionID:
7538 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
7540 FreeRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
7543 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
7545 FreeRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
7548 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
7550 FreeRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
7555 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
7561 RIC_FREE(ricSubscriptionModReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionModificationRequest_IEs_t));
7564 RIC_FREE(ricSubscriptionModReq->protocolIEs.list.array, ricSubscriptionModReq->protocolIEs.list.size);
7566 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7568 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
7572 /*******************************************************************
7574 * @brief Build Ric subscription action to be modify list
7578 * Function : BuildRicSubsActionToBeModify
7580 * Functionality: Build Ric subscription action to be modify list
7583 * RICactions_ToBeModifiedForModification_List_t to be filled
7584 * Num of action to be modify
7585 * List of action to be modify
7587 * @return ROK - success
7590 ******************************************************************/
7592 uint8_t BuildRicSubsActionToBeModify(RICactions_ToBeModifiedForModification_List_t *modifyActionList, uint8_t numOfActionToBeModify, ActionInfo *actionToBeModify)
7595 RICaction_ToBeModifiedForModification_ItemIEs_t *modifiedActionItemIe=NULLP;
7597 modifyActionList->list.count = numOfActionToBeModify;
7598 modifyActionList->list.size = modifyActionList->list.count * sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t*);
7599 RIC_ALLOC(modifyActionList->list.array, modifyActionList->list.size);
7600 if(!modifyActionList->list.array)
7602 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7606 for(arrIdx = 0; arrIdx< modifyActionList->list.count; arrIdx++)
7608 RIC_ALLOC(modifyActionList->list.array[arrIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t));
7609 if(!modifyActionList->list.array[arrIdx])
7611 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7614 modifiedActionItemIe = (RICaction_ToBeModifiedForModification_ItemIEs_t*)modifyActionList->list.array[arrIdx];
7615 modifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item;
7616 modifiedActionItemIe->criticality = CriticalityE2_ignore;
7617 modifiedActionItemIe->value.present = RICaction_ToBeModifiedForModification_ItemIEs__value_PR_RICaction_ToBeModifiedForModification_Item;
7618 modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID = actionToBeModify[arrIdx].actionId;
7620 /* RIC Action Definition */
7621 RIC_ALLOC(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
7622 if(!modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
7624 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7628 if(fillRicActionDef(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition,\
7629 actionToBeModify[arrIdx].actionId, CONFIG_MOD) != ROK)
7631 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7639 /*******************************************************************
7641 * @brief Build Ric subscription action to be removed list
7645 * Function : BuildRicSubsActionToBeRemoved
7647 * Functionality: Build Ric subscription action to be removed list
7650 * RICactions_ToBeRemovedForModification_List_t to be filled
7651 * Num Of Action To Be Remove
7652 * Action remove list
7654 * @return ROK - success
7657 ******************************************************************/
7659 uint8_t BuildRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *removeActionList, uint8_t numOfActionToBeRemove, ActionInfo *actionToBeRemove)
7662 RICaction_ToBeRemovedForModification_ItemIEs_t *removeActionItemIe=NULLP;
7664 removeActionList->list.count = numOfActionToBeRemove;
7665 removeActionList->list.size = removeActionList->list.count * sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t*);
7666 RIC_ALLOC(removeActionList->list.array, removeActionList->list.size);
7667 if(!removeActionList->list.array)
7669 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7673 for(arrIdx = 0; arrIdx< removeActionList->list.count; arrIdx++)
7675 RIC_ALLOC(removeActionList->list.array[arrIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t));
7676 if(!removeActionList->list.array[arrIdx])
7678 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7681 removeActionItemIe = (RICaction_ToBeRemovedForModification_ItemIEs_t*)removeActionList->list.array[arrIdx];
7682 removeActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item;
7683 removeActionItemIe->criticality = CriticalityE2_ignore;
7684 removeActionItemIe->value.present = RICaction_ToBeRemovedForModification_ItemIEs__value_PR_RICaction_ToBeRemovedForModification_Item;
7685 removeActionItemIe->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID = actionToBeRemove[arrIdx].actionId;
7690 /*******************************************************************
7692 * @brief Build Ric subscription action to be added list
7696 * Function : BuildRicSubsActionToBeAdded
7698 * Functionality: Build Ric subscription action to be added list
7701 * RICactions_ToBeAddedForModification_List_t to be filled
7702 * Num Of Action To Be added
7705 * @return ROK - success
7708 ******************************************************************/
7710 uint8_t BuildRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *addedActionList, RicSubscription **ricSubsInfo, uint8_t numOfActionToBeAdded, ActionInfo *actionToBeAdded)
7713 CmLList *actionNode=NULLP;
7714 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe;
7716 addedActionList->list.count = numOfActionToBeAdded;
7717 addedActionList->list.size = addedActionList->list.count * sizeof(RICaction_ToBeAddedForModification_ItemIEs_t*);
7718 RIC_ALLOC(addedActionList->list.array, addedActionList->list.size);
7719 if(!addedActionList->list.array)
7721 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7725 for(arrIdx = 0; arrIdx< addedActionList->list.count; arrIdx++)
7727 RIC_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t));
7728 if(!addedActionList->list.array[arrIdx])
7730 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7733 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx];
7734 addedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item;
7735 addedActionItemIe->criticality = CriticalityE2_ignore;
7736 addedActionItemIe->value.present = RICaction_ToBeAddedForModification_ItemIEs__value_PR_RICaction_ToBeAddedForModification_Item;
7737 addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionID = actionToBeAdded[arrIdx].actionId;
7739 addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionType = RICactionType_report;
7741 if(fillRicActionDef(&addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition, \
7742 actionToBeAdded[arrIdx].actionId, CONFIG_ADD) != ROK)
7744 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7748 actionNode = addRicSubsAction((*ricSubsInfo)->actionSequence.count, &(*ricSubsInfo)->actionSequence);
7749 if(actionNode == NULLP)
7751 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7758 /*******************************************************************
7760 * @brief Builds and Send the RicSubscriptionModReq
7764 * Function : BuildAndSendRicSubscriptionModReq
7766 * Functionality:Builds and Send the RicSubscriptionModReq
7770 * Ric subs information
7771 * List of ric subs action which needs to modify/add/remove
7772 * @return ROK - success
7775 ******************************************************************/
7777 uint8_t BuildAndSendRicSubscriptionModReq(DuDb *duDb, RicSubscription **ricSubsInfo, RicSubsModReq ricSubsModReq)
7779 uint8_t ret = RFAILED;
7780 uint8_t elementCnt = 0;
7781 uint8_t idx = 0, cfgIdx=0;
7782 asn_enc_rval_t encRetVal; /* Encoder return value */
7783 E2AP_PDU_t *e2apRicMsg = NULL;
7784 RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
7785 RanFunction *ranFuncDb = &duDb->ranFunction[0];
7786 CmLList *subscriptionNode = NULLP;
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 Handles received E2AP message and sends back response
8013 * Function : E2APMsgHdlr
8016 * - Decodes received E2AP control message
8017 * - Prepares response message, encodes and sends to SCTP
8020 * @return ROK - success
8023 * ****************************************************************/
8024 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
8030 E2AP_PDU_t *e2apMsg;
8031 asn_dec_rval_t rval; /* Decoder return value */
8032 E2AP_PDU_t e2apasnmsg ;
8034 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
8035 ODU_PRINT_MSG(mBuf, 0,0);
8037 /* Copy mBuf into char array to decode it */
8038 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
8039 RIC_ALLOC(recvBuf, (Size)recvBufLen);
8041 if(recvBuf == NULLP)
8043 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
8046 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
8048 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
8052 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
8053 for(i=0; i< recvBufLen; i++)
8055 DU_LOG("%x",recvBuf[i]);
8058 /* Decoding flat buffer into E2AP messsage */
8059 e2apMsg = &e2apasnmsg;
8060 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
8062 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
8063 RIC_FREE(recvBuf, (Size)recvBufLen);
8065 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
8067 DU_LOG("\nERROR --> E2AP : ASN decode failed");
8071 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8073 switch(e2apMsg->present)
8075 case E2AP_PDU_PR_initiatingMessage:
8077 switch(e2apMsg->choice.initiatingMessage->value.present)
8079 case InitiatingMessageE2__value_PR_E2setupRequest:
8081 DU_LOG("\nINFO --> E2AP : E2 setup request received");
8082 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
8085 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
8087 DU_LOG("\nINFO --> E2AP : E2 node config update received");
8088 ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate);
8091 case InitiatingMessageE2__value_PR_ResetRequestE2:
8093 DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
8094 ProcResetRequest(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
8097 case InitiatingMessageE2__value_PR_RICindication:
8099 DU_LOG("\nINFO --> E2AP : RIC Indication received");
8102 case InitiatingMessageE2__value_PR_RICserviceUpdate:
8104 DU_LOG("\nINFO --> E2AP : RIC Service update received");
8105 ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate);
8108 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired:
8110 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Required");
8111 ProcRicSubsModReqd(*duId, \
8112 &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired);
8115 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired:
8117 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Required");
8118 ProcRicSubsDeleteReqd(*duId, \
8119 &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired);
8123 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
8125 DU_LOG("\nINFO --> E2AP : Error indication received");
8128 case InitiatingMessageE2__value_PR_E2RemovalRequest:
8130 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
8131 procE2RemovalRequest(*duId,\
8132 &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest);
8137 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \
8138 e2apMsg->choice.initiatingMessage->value.present);
8141 }/* End of switch(initiatingMessage) */
8144 case E2AP_PDU_PR_successfulOutcome:
8146 switch(e2apMsg->choice.successfulOutcome->value.present)
8148 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
8150 DU_LOG("\nINFO --> E2AP : Reset response received");
8151 ProcResetResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2);
8154 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
8156 ProcRicSubscriptionResponse(*duId, \
8157 &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse);
8160 case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
8162 ProcE2RemovalResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse);
8165 case SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge:
8167 ProcE2ConnectionUpdateAck(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge);
8170 case SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse:
8172 ProcRicSubsDeleteRsp(*duId, &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse);
8177 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \
8178 e2apMsg->choice.successfulOutcome->value.present);
8185 case E2AP_PDU_PR_unsuccessfulOutcome:
8187 switch(e2apMsg->choice.successfulOutcome->value.present)
8189 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure:
8191 ProcRicSubscriptionFailure(*duId, \
8192 &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure);
8195 case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
8197 ProcE2RemovalFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure);
8200 case UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure:
8202 ProcE2connectionUpdateFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure);
8205 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteFailure:
8207 ProcRicSubsDeleteFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure);
8210 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure:
8212 ProcRicSubsModificationFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure);
8217 DU_LOG("\nERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \
8218 e2apMsg->choice.unsuccessfulOutcome->value.present);
8226 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
8230 }/* End of switch(e2apMsg->present) */
8231 } /* End of E2APMsgHdlr */
8234 /**********************************************************************
8236 **********************************************************************/