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"
48 char encBuf[ENC_BUF_MAX_LEN];
49 /*******************************************************************
51 * @brief Printing Type and Cause of failure
55 * Function : printE2ErrorCause
57 * Functionality: Printing Type and Cause of failure
59 * @params[in] E2 Cause
62 ******************************************************************/
64 void printE2ErrorCause(CauseE2_t *cause)
66 switch(cause->present)
68 case CauseE2_PR_ricRequest:
70 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Request", cause->choice.ricRequest);
73 case CauseE2_PR_ricService:
75 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Service", cause->choice.ricService);
78 case CauseE2_PR_e2Node:
80 DU_LOG("Failure_Type [%s] Cause [%ld]", "E2_Node", cause->choice.e2Node);
83 case CauseE2_PR_transport:
85 DU_LOG("Failure_Type [%s] Cause [%ld]", "Transport", cause->choice.transport);
88 case CauseE2_PR_protocol:
90 DU_LOG("Failure_Type [%s] Cause [%ld]", "Protocol", cause->choice.protocol);
95 DU_LOG("Failure_Type [%s] Cause [%ld]", "Miscellaneous", cause->choice.misc);
100 DU_LOG("Failure_Type and Cause unknown");
106 /*******************************************************************
108 * @brief fill E2 failure cause
112 * Function : fillE2FailureCause
114 * Functionality: fill E2 failure cause
115 * @return ROK - success
118 ******************************************************************/
120 void fillE2FailureCause(CauseE2_t *cause, CauseE2_PR causePresent, uint8_t reason)
122 cause->present = causePresent;
124 switch(cause->present)
126 case CauseE2_PR_ricRequest:
127 cause->choice.ricRequest = reason;
129 case CauseE2_PR_ricService:
130 cause->choice.ricService = reason;
132 case CauseE2_PR_e2Node:
133 cause->choice.e2Node = reason;
135 case CauseE2_PR_transport:
136 cause->choice.transport = reason;
138 case CauseE2_PR_protocol:
139 cause->choice.protocol = reason;
141 case CauseE2_PR_misc:
142 cause->choice.misc = reason;
145 cause->choice.misc = CauseE2Misc_unspecified;
150 /*******************************************************************
152 * @brief Assigns new transaction id to RIC initiated procedure
156 * Function : assignTransactionId
158 * Functionality: Assigns new transaction id to a RIC initiated
161 * @params[in] Region region
163 * @return ROK - success
166 * ****************************************************************/
168 uint8_t assignTransactionId(DuDb *duDb)
170 uint8_t currTransId = duDb->ricTransIdCounter;
172 /* Update to next valid value */
173 duDb->ricTransIdCounter++;
174 if(duDb->ricTransIdCounter == MAX_NUM_TRANSACTION)
175 duDb->ricTransIdCounter = 0;
180 /*******************************************************************
182 * @brief add RIC Subs action info
186 * Function : addRicSubsAction
188 * Functionality: add Ric Subs action info
193 * @return ROK - success
196 ******************************************************************/
197 CmLList *addRicSubsAction(uint8_t ricActionID, CmLListCp *actionSequence)
199 ActionInfo *actionDb = NULLP;
200 CmLList *actionNode=NULLP;
202 RIC_ALLOC(actionDb, sizeof(ActionInfo));
205 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
209 actionDb->actionId = ricActionID;
210 RIC_ALLOC(actionNode, sizeof(CmLList));
213 actionNode->node = (PTR) actionDb;
214 cmLListAdd2Tail(actionSequence, actionNode);
218 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
219 RIC_FREE(actionDb, sizeof(ActionInfo));
226 /*******************************************************************
228 * @brief Sends E2 msg over SCTP
232 * Function : SendE2APMsg
234 * Functionality: Sends E2 msg over SCTP
236 * @params[in] Region region
238 * @return ROK - success
241 * ****************************************************************/
243 uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId)
247 if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
249 if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
251 ODU_PRINT_MSG(mBuf, 0,0);
253 if(sctpSend(duId, mBuf) != ROK)
255 DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
256 ODU_PUT_MSG_BUF(mBuf);
262 DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
263 ODU_PUT_MSG_BUF(mBuf);
266 ODU_PUT_MSG_BUF(mBuf);
270 DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
277 /*******************************************************************
279 * @brief Deallocate the memory allocated for RemovalRequest msg
283 * Function : FreeRemovalRequest
286 * - freeing the memory allocated for RemovalRequest
288 * @params[in] E2AP_PDU_t *e2apMsg
289 * @return ROK - success
292 * ****************************************************************/
293 void FreeRemovalRequest(E2AP_PDU_t *e2apMsg)
296 E2RemovalRequest_t *removalReq = NULLP;
300 if(e2apMsg->choice.initiatingMessage != NULLP)
302 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
303 if(removalReq->protocolIEs.list.array)
305 for(ieIdx = 0; ieIdx < removalReq->protocolIEs.list.count; ieIdx++)
307 RIC_FREE(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
309 RIC_FREE(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
311 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
313 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
317 /*******************************************************************
319 * @brief Build and send the removal request msg
323 * Function : BuildAndSendRemovalRequest
326 * - Buld and send the removal request msg to E2 node
332 * @return ROK - success
335 * ****************************************************************/
336 uint8_t BuildAndSendRemovalRequest(DuDb *duDb)
338 uint8_t ieIdx = 0, elementCnt = 0;
339 uint16_t transId = 0;
340 uint8_t ret = RFAILED;
341 E2AP_PDU_t *e2apMsg = NULLP;
342 E2RemovalRequest_t *removalReq = NULLP;
343 asn_enc_rval_t encRetVal; /* Encoder return value */
345 DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
349 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
352 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
356 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
357 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
358 if(e2apMsg->choice.initiatingMessage == NULLP)
360 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
364 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2removal;
365 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
366 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2RemovalRequest;
367 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
370 removalReq->protocolIEs.list.count = elementCnt;
371 removalReq->protocolIEs.list.size = elementCnt * sizeof(E2RemovalRequestIEs_t *);
373 RIC_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
374 if(!removalReq->protocolIEs.list.array)
376 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
380 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
382 RIC_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
383 if(!removalReq->protocolIEs.list.array[ieIdx])
385 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
390 /* In case of failure */
391 if(ieIdx < elementCnt)
395 removalReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
396 removalReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
397 removalReq->protocolIEs.list.array[ieIdx]->value.present = E2RemovalRequestIEs__value_PR_TransactionID;
398 transId = assignTransactionId(duDb);
399 removalReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
401 /* Prints the Msg formed */
402 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
404 memset(encBuf, 0, ENC_BUF_MAX_LEN);
406 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
408 if(encRetVal.encoded == ENCODE_FAIL)
410 DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
411 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
416 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
417 #ifdef DEBUG_ASN_PRINT
418 for(int i=0; i< encBufSize; i++)
420 printf("%x",encBuf[i]);
424 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
426 DU_LOG("\nERROR --> E2AP : Sending removal request failed");
435 /* Free all memory */
436 FreeRemovalRequest(e2apMsg);
440 /*******************************************************************
442 * @brief Fetches RAN Function DB
446 * Function : fetchRanFuncFromRanFuncId
448 * Functionality: Fetches RAN function DB from E2AP DB using
451 * @params[in] RAN Function ID
452 * @return RAN Function DB
453 * NULL, in case of failure
455 * ****************************************************************/
456 RanFunction *fetchRanFuncFromRanFuncId(DuDb *duDb, uint16_t ranFuncId)
458 RanFunction *ranFuncDb = NULLP;
460 /* Fetch RAN Function DB */
461 if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
463 ranFuncDb = &duDb->ranFunction[ranFuncId-1];
467 DU_LOG("\nERROR --> DU_APP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId);
473 /*******************************************************************
475 * @brief Fetch subscripton DB
479 * Function : fetchSubsInfoFromRicReqId
481 * Functionality: Fetches subscription DB from RAN Function DB
482 * using RIC Request ID
484 * @params[in] RIC Request ID
486 * Pointer to RIC Subscription node to be searched
487 * @return RIC Subscription from RAN Function's subcription list
488 * NULL, in case of failure
490 * ****************************************************************/
491 RicSubscription *fetchSubsInfoFromRicReqId(RicRequestId ricReqId, RanFunction *ranFuncDb, CmLList **ricSubscriptionNode)
493 RicSubscription *ricSubscriptionInfo = NULLP;
495 /* Fetch subscription detail in RAN Function DB */
496 CM_LLIST_FIRST_NODE(&ranFuncDb->subscriptionList, *ricSubscriptionNode);
497 while(*ricSubscriptionNode)
499 ricSubscriptionInfo = (RicSubscription *)((*ricSubscriptionNode)->node);
500 if(ricSubscriptionInfo && (ricSubscriptionInfo->requestId.requestorId == ricReqId.requestorId) &&
501 (ricSubscriptionInfo->requestId.instanceId == ricReqId.instanceId))
505 *ricSubscriptionNode = (*ricSubscriptionNode)->next;
506 ricSubscriptionInfo = NULLP;
509 if(!ricSubscriptionInfo)
511 DU_LOG("\nERROR --> E2AP : fetchSubsInfoFromRicReqId: Subscription not found for Requestor ID [%d] \
512 Instance ID [%d] in RAN Function ID [%d]", ricReqId.requestorId, ricReqId.instanceId, ranFuncDb->id);
515 return ricSubscriptionInfo;
518 /*******************************************************************
520 * @brief Fetch Action details
524 * Function : fetchActionInfoFromActionId
526 * Functionality: Fetch action details from RIC subscription DB
529 * @params[in] Action ID
530 * RIC Subscription DB
532 * @return Action Info DB
533 * NULL, in case of failure
535 * ****************************************************************/
536 ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo, CmLList ** actionNode)
538 ActionInfo *actionInfoDb = NULLP;
540 CM_LLIST_FIRST_NODE(&ricSubscriptionInfo->actionSequence, *actionNode);
543 actionInfoDb = (ActionInfo*)((*actionNode)->node);
544 if(actionInfoDb->actionId == actionId)
548 *actionNode= (*actionNode)->next;
550 if(actionInfoDb==NULLP)
552 DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
553 subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
554 ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
560 /******************************************************************
562 * @brief Search E2 node component with the help of interface type
567 * Function : fetchE2NodeComponentInfo
569 * Functionality: Search E2 node component
574 * Pointer to E2 component node to be searched
577 * ****************************************************************/
579 E2NodeComponent *fetchE2NodeComponentInfo(DuDb *duDb, InterfaceType interfaceType,CmLList **e2ComponentNode)
581 E2NodeComponent *e2NodeComponentInfo=NULLP;
583 if(duDb->e2NodeComponent.count)
585 CM_LLIST_FIRST_NODE(&duDb->e2NodeComponent, *e2ComponentNode);
586 while(*e2ComponentNode)
588 e2NodeComponentInfo = (E2NodeComponent*)((*e2ComponentNode)->node);
589 if((e2NodeComponentInfo->interfaceType == interfaceType))
594 *e2ComponentNode = (*e2ComponentNode)->next;
595 e2NodeComponentInfo = NULLP;
598 return e2NodeComponentInfo;
601 /*******************************************************************
603 * @brief update E2 node config list
607 * Function : updateE2NodeConfigList
610 * - update E2 node config list
614 * Configuration which need to update in Database
616 * @return ROK - success
619 * ****************************************************************/
620 uint8_t updateE2NodeConfigList(DuDb **duDb, uint8_t protocolId, E2NodeConfigItem *tmpCfg)
623 E2NodeComponent * e2NodeComponentInfo;
624 bool configFound= false;
628 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
630 /* Adding the new e2 node component in DB*/
631 RIC_ALLOC(e2NodeComponentInfo, sizeof(E2NodeComponent));
632 e2NodeComponentInfo->interfaceType = tmpCfg->componentInfo.interfaceType;
633 e2NodeComponentInfo->componentId =tmpCfg->componentInfo.componentId;
634 RIC_ALLOC(node, sizeof(CmLList));
637 node->node = (PTR) e2NodeComponentInfo;
638 cmLListAdd2Tail(&(*duDb)->e2NodeComponent, node);
643 DU_LOG("\nERROR --> E2AP : Memory allocation failed for e2NodeComponentList node");
644 RIC_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
649 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
651 /* searching for information in a database */
652 e2NodeComponentInfo = fetchE2NodeComponentInfo((*duDb),tmpCfg->componentInfo.interfaceType, &node);
653 if(!e2NodeComponentInfo)
655 DU_LOG("\nERROR --> E2AP : Failed to find the e2 component node");
658 /* If the node is present then update the value */
659 e2NodeComponentInfo->componentId =tmpCfg->componentInfo.componentId;
663 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
665 /* searching for information in a database */
666 e2NodeComponentInfo = fetchE2NodeComponentInfo((*duDb),tmpCfg->componentInfo.interfaceType, &node);
667 if(!e2NodeComponentInfo)
669 DU_LOG("\nERROR --> E2AP : Failed to find the e2 component node");
672 /* Delete the node from the list */
673 e2NodeComponentInfo->componentId = tmpCfg->componentInfo.componentId;
674 cmLListDelFrm(&(*duDb)->e2NodeComponent, node);
675 RIC_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
681 /* If the configuration update was successful, then mark the isSuccessful as
682 * true; otherwise, mark it as false. */
683 if(configFound == true)
684 tmpCfg->isSuccessful = true;
686 tmpCfg->isSuccessful = false;
691 /*******************************************************************
693 * @brief Handling the E2 node configuration depending on the add,
694 * update, or remove configuration type
698 * Function : handleE2NodeComponentAction
701 * - Handling the E2 node configuration depending on the add,
702 * update, or remove configuration type
705 * Pointer to e2NodeCfg which has info
707 * E2NodeConfigItem to be filled
709 * @return ROK - success
712 * ****************************************************************/
714 uint8_t handleE2NodeComponentAction(DuDb *duDb, PTR e2NodeCfg, uint8_t protocolId, E2NodeConfigItem *storeCfg)
716 uint8_t configFound = ROK;
717 E2NodeConfigItem tmpCfg;
718 E2nodeComponentID_t componentId;
719 E2nodeComponentInterfaceType_t interface;
720 E2nodeComponentConfigAddition_Item_t *addCfg=NULL;
721 E2nodeComponentConfigUpdate_Item_t *updateCfg=NULL;
722 E2nodeComponentConfigRemoval_Item_t *removeCfg=NULL;
724 /* fetching the interface and component id information from the e2NodeCfg */
725 memset(storeCfg, 0, sizeof(E2NodeConfigItem));
726 storeCfg->isSuccessful=false;
727 memset(&tmpCfg, 0, sizeof(E2NodeConfigItem));
731 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
733 addCfg = (E2nodeComponentConfigAddition_Item_t *)e2NodeCfg;
734 interface = addCfg->e2nodeComponentInterfaceType;
735 componentId = addCfg->e2nodeComponentID;
738 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
740 updateCfg = (E2nodeComponentConfigUpdate_Item_t *)e2NodeCfg;
741 interface = updateCfg->e2nodeComponentInterfaceType;
742 componentId = updateCfg->e2nodeComponentID;
745 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
747 removeCfg = (E2nodeComponentConfigRemoval_Item_t*)e2NodeCfg;
748 interface = removeCfg->e2nodeComponentInterfaceType;
749 componentId = removeCfg->e2nodeComponentID;
754 /* Storing the information in temporary structure */
755 tmpCfg.componentInfo.interfaceType = interface;
757 switch(componentId.present)
759 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
761 if(componentId.choice.e2nodeComponentInterfaceTypeF1)
763 tmpCfg.componentInfo.componentId = componentId.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
773 /* Updating the database configuration */
774 configFound = updateE2NodeConfigList(&duDb, protocolId, &tmpCfg);
776 memcpy(storeCfg, &tmpCfg,sizeof(E2NodeConfigItem));
781 /*******************************************************************
783 * @brief deallocate memory allocated in E2 Node Config Update Failure
787 * Function : FreeE2ConfigUpdateFail
789 * Functionality: deallocate memory allocated in E2 Node Config Update Failure
791 * @params[in] E2AP_PDU_t *e2apMsg
794 * ****************************************************************/
796 void FreeE2ConfigUpdateFail(E2AP_PDU_t *e2apMsg)
799 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
803 if(e2apMsg->choice.unsuccessfulOutcome)
805 e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
806 if(e2NodeCfgUpdFail->protocolIEs.list.array)
808 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
810 RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateFailure_IEs_t));
812 RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array, e2NodeCfgUpdFail->protocolIEs.list.size);
814 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
816 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
820 /*******************************************************************
822 * @brief Buld and send the E2 Node Config Update failure
826 * Function : BuildAndSendE2NodeConfigUpdateFailure
829 * - Buld and send the E2 Node Config Update failure
830 * @return ROK - success
833 * ****************************************************************/
835 uint8_t BuildAndSendE2NodeConfigUpdateFailure(uint32_t duId, uint16_t transId, uint8_t causeInfo, uint8_t causeReason)
837 E2AP_PDU_t *e2apMsg = NULL;
838 asn_enc_rval_t encRetVal;
840 uint8_t elementCnt=0;
841 bool memAllocFailed = false;
842 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdateFail=NULL;
844 DU_LOG("\nINFO --> E2AP : Building E2 Node Config Update failure\n");
847 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
850 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
853 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
854 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
855 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
857 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
861 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
862 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
863 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure;
864 e2NodeCfgUpdateFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
867 e2NodeCfgUpdateFail->protocolIEs.list.count = elementCnt;
868 e2NodeCfgUpdateFail->protocolIEs.list.size = elementCnt * sizeof(struct E2nodeConfigurationUpdateFailure_IEs *);
870 RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array, e2NodeCfgUpdateFail->protocolIEs.list.size);
871 if(e2NodeCfgUpdateFail->protocolIEs.list.array == NULLP)
873 DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure array failed");
877 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
879 RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx], sizeof(struct E2nodeConfigurationUpdateFailure_IEs));
880 if(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx] == NULLP)
882 DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure IEs failed");
883 memAllocFailed = true;
888 if(memAllocFailed == true)
895 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
896 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
897 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
898 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
901 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
902 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
903 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
904 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = causeInfo;
905 if(causeInfo == CauseE2_PR_e2Node)
906 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.e2Node = causeReason;
908 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.misc = causeReason;
911 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
912 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
913 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
914 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
916 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
917 memset(encBuf, 0, ENC_BUF_MAX_LEN);
919 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
921 /* Check encode results */
922 if(encRetVal.encoded == ENCODE_FAIL)
924 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node Config Update failure structure (at %s)\n",\
925 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
930 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node Config Update Failure\n");
931 for(int i=0; i< encBufSize; i++)
933 DU_LOG("%x",encBuf[i]);
937 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
939 DU_LOG("\nERROR --> E2AP : Sending E2 Node Config Update Failure failed");
945 FreeE2ConfigUpdateFail(e2apMsg);
949 /*******************************************************************
951 * @brief process the E2 node configuration update
955 * Function : ProcE2NodeConfigUpdate
957 * Functionality: Process E2 node configuration update
961 * Pointer to E2nodeConfigurationUpdate
964 ******************************************************************/
966 void ProcE2NodeConfigUpdate(uint32_t duId, E2nodeConfigurationUpdate_t *e2NodeConfigUpdate)
969 E2NodeConfigList tmpE2NodeList;
971 uint8_t ieIdx = 0, duIdx = 0, elementCnt=0;
972 uint16_t transId = 0;
973 E2nodeComponentConfigAddition_List_t *e2NodeAddList=NULL;
974 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe=NULL;
975 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
976 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList=NULLP;
977 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe=NULLP;
978 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULLP;
979 E2nodeComponentConfigRemoval_List_t *e2NodeRemoveList=NULL;
980 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItemIe=NULL;
981 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
983 SEARCH_DU_DB(duIdx, duId, duDb);
986 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
990 memset(&tmpE2NodeList, 0, sizeof(E2NodeConfigList));
991 if(!e2NodeConfigUpdate)
993 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate pointer is null");
996 if(!e2NodeConfigUpdate->protocolIEs.list.array)
998 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate array pointer is null");
1002 elementCnt = e2NodeConfigUpdate->protocolIEs.list.count;
1003 for(ieIdx=0; ieIdx < e2NodeConfigUpdate->protocolIEs.list.count; ieIdx++)
1005 if(!e2NodeConfigUpdate->protocolIEs.list.array[ieIdx])
1007 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate array idx %d pointer is null",arrIdx);
1011 switch(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->id)
1013 case ProtocolIE_IDE2_id_TransactionID:
1015 transId = e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
1016 if(transId < 0 || transId > 255)
1018 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
1024 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1026 e2NodeAddList =&e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigAddition_List;
1027 if(e2NodeAddList->list.array)
1029 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
1031 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
1032 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
1033 /* Storing the E2 node information in DB */
1034 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeAddItem, ProtocolIE_IDE2_id_E2nodeComponentConfigAddition,\
1035 &tmpE2NodeList.addedE2Node[tmpE2NodeList.addedE2NodeCount++]) != ROK)
1037 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1044 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
1046 e2NodeUpdateList =&e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigUpdate_List;
1047 if(e2NodeUpdateList->list.array)
1049 for(arrIdx = 0; arrIdx< e2NodeUpdateList->list.count; arrIdx++)
1051 e2NodeUpdateItemIe = (E2nodeComponentConfigUpdate_ItemIEs_t*) e2NodeUpdateList->list.array[arrIdx];
1052 e2NodeUpdateItem = &e2NodeUpdateItemIe->value.choice.E2nodeComponentConfigUpdate_Item;
1054 /* Updating the E2 node information in DB */
1055 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeUpdateItem, ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate,\
1056 &tmpE2NodeList.updatedE2Node[tmpE2NodeList.updatedE2NodeCount++]) != ROK)
1058 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1065 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
1067 e2NodeRemoveList = &e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigRemoval_List;
1068 if(e2NodeRemoveList->list.array)
1070 for(arrIdx = 0; arrIdx< e2NodeRemoveList->list.count; arrIdx++)
1072 e2NodeRemovalItemIe = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemoveList->list.array[arrIdx];
1073 e2NodeRemovalItem = &e2NodeRemovalItemIe->value.choice.E2nodeComponentConfigRemoval_Item;
1075 /* Removing the E2 node information in DB */
1076 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeRemovalItem, ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval,\
1077 &tmpE2NodeList.removedE2Node[tmpE2NodeList.removedE2NodeCount++]) != ROK)
1079 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1092 /* If all of the IEs are processed successfully, we will send an e2 node
1093 * config update ack message.
1094 * else we will be sendinf e2 node config update failure */
1095 if(elementCnt == ieIdx)
1097 if(BuildAndSendE2NodeConfigUpdateAck(duDb, transId, &tmpE2NodeList) !=ROK)
1099 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 node config ack");
1105 if(BuildAndSendE2NodeConfigUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
1107 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 node config Failure");
1112 /*******************************************************************
1114 * @brief Builds Global RIC Id Params
1118 * Function : BuildGlobalRicId
1120 * Functionality: Building the Plmn and ric id
1122 * @params[in] GlobalRIC_ID_t *ricId
1123 * @return ROK - success
1126 * ****************************************************************/
1128 uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId)
1131 uint8_t byteSize = 3;
1135 ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
1136 RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
1137 buildPlmnId(ricCb.ricCfgParams.plmn , ricId->pLMN_Identity.buf);
1139 ricId->ric_ID.size = byteSize * sizeof(uint8_t);
1140 RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
1141 fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
1146 /*******************************************************************
1148 * @brief deallocate the memory allocated in E2SetupResponse
1152 * Function : FreeE2SetupRsp
1154 * Functionality: deallocate the memory allocated in E2SetupResponse
1156 * @params[in] E2AP_PDU_t *e2apMsg
1159 * ****************************************************************/
1160 void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
1162 uint8_t arrIdx = 0, e2NodeConfigIdx=0, ranFuncIdx=0;
1163 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
1164 E2setupResponse_t *e2SetupRsp=NULL;
1165 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULL;
1166 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULL;
1167 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULL;
1171 if(e2apMsg->choice.successfulOutcome)
1173 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
1174 if(e2SetupRsp->protocolIEs.list.array)
1176 for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
1178 switch(e2SetupRsp->protocolIEs.list.array[arrIdx]->id)
1180 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
1182 ranFuncAcceptedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
1183 if(ranFuncAcceptedList->list.array)
1185 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
1187 if(ranFuncAcceptedList->list.array[ranFuncIdx])
1189 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1192 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
1196 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1198 e2NodeConfigAdditionAckList =&e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
1199 if(e2NodeConfigAdditionAckList->list.count)
1201 for(e2NodeConfigIdx=0; e2NodeConfigIdx<e2NodeConfigAdditionAckList->list.count; e2NodeConfigIdx++)
1203 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2NodeConfigIdx];
1204 if(e2NodeAddAckItemIe)
1206 f1InterfaceInfo = e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
1209 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
1210 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
1212 RIC_FREE(e2NodeAddAckItemIe, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
1215 RIC_FREE(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
1220 RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
1222 RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
1224 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1226 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1230 /*******************************************************************
1232 * @brief fill e2 node configuration for ack msg
1236 * Function : fillE2NodeConfigAck
1239 * - fill e2 node configuration for ack msg
1242 * Pointer to e2NodeCfg to be filled
1244 * E2 Node Component information
1245 * Is successful or failure response
1246 * @return ROK - success
1249 * ****************************************************************/
1251 uint8_t fillE2NodeConfigAck(PTR e2NodeCfg, uint8_t procedureCode, E2NodeComponent *componentInfo, bool isSuccessful)
1253 E2nodeComponentID_t *e2nodeComponentID=NULLP;
1254 E2nodeComponentInterfaceType_t *e2nodeComponentInterfaceType=NULLP;
1255 E2nodeComponentConfigurationAck_t *e2nodeComponentConfigurationAck=NULLP;
1256 E2nodeComponentConfigRemovalAck_Item_t *removalAckItem=NULLP;
1257 E2nodeComponentConfigUpdateAck_Item_t *updateAckItem=NULLP;
1258 E2nodeComponentConfigAdditionAck_Item_t *additionAckItem=NULLP;
1260 /* filling the interface type, component id, configuration ack based on the
1261 * e2 node configuration add, update, delete type */
1262 switch(procedureCode)
1264 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1266 additionAckItem = (E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg;
1267 e2nodeComponentInterfaceType = &((E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg)->e2nodeComponentInterfaceType;
1268 e2nodeComponentID = &additionAckItem->e2nodeComponentID;
1269 e2nodeComponentConfigurationAck = &additionAckItem->e2nodeComponentConfigurationAck;
1272 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
1274 updateAckItem = (E2nodeComponentConfigUpdateAck_Item_t*) e2NodeCfg;
1275 e2nodeComponentInterfaceType = &updateAckItem->e2nodeComponentInterfaceType;
1276 e2nodeComponentID = &updateAckItem->e2nodeComponentID;
1277 e2nodeComponentConfigurationAck = &updateAckItem->e2nodeComponentConfigurationAck;
1280 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
1282 removalAckItem= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
1283 e2nodeComponentInterfaceType = &removalAckItem->e2nodeComponentInterfaceType;
1284 e2nodeComponentID = &removalAckItem->e2nodeComponentID;
1285 e2nodeComponentConfigurationAck = &removalAckItem->e2nodeComponentConfigurationAck;
1290 /* >E2 Node Component interface type */
1291 if(componentInfo->interfaceType>=NG && componentInfo->interfaceType<=X2)
1293 *e2nodeComponentInterfaceType = componentInfo->interfaceType;
1297 DU_LOG("\nERROR --> E2AP: Received an invalid interface value %d",componentInfo->interfaceType);
1301 if(*e2nodeComponentInterfaceType == E2nodeComponentInterfaceType_f1)
1303 /* >E2 Node Component ID */
1304 e2nodeComponentID->present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
1305 RIC_ALLOC(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
1306 if(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
1308 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1311 e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
1312 RIC_ALLOC(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1314 if(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
1316 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1319 e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = componentInfo->componentId;
1324 /* >E2 Node Component Configuration Acknowledge*/
1325 e2nodeComponentConfigurationAck->updateOutcome = E2nodeComponentConfigurationAck__updateOutcome_success;
1329 /* >E2 Node Component Configuration Acknowledge*/
1330 e2nodeComponentConfigurationAck->updateOutcome = E2nodeComponentConfigurationAck__updateOutcome_failure;
1331 RIC_ALLOC(e2nodeComponentConfigurationAck->failureCauseE2, sizeof(struct CauseE2));
1332 if(e2nodeComponentConfigurationAck->failureCauseE2)
1334 fillE2FailureCause(e2nodeComponentConfigurationAck->failureCauseE2, CauseE2_PR_e2Node, CauseE2node_e2node_component_unknown);
1338 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1345 /*******************************************************************
1347 * @brief Build E2node Component config addition ack list
1351 * Function : BuildE2nodeComponentConfigAdditionAck
1353 * Functionality: Build E2node Component config addition ack list
1356 * E2nodeComponentConfigAdditionAck_List to be filled
1357 * Count of e2 node to be added
1358 * list of e2 node cfg to be added
1360 * @return ROK - success
1362 * ****************************************************************/
1364 uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, \
1365 uint16_t addedE2NodeCount, E2NodeConfigItem *addedE2Node)
1367 uint16_t arrIdx = 0;
1368 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULLP;
1370 e2NodeConfigAdditionAckList->list.count = addedE2NodeCount;
1372 e2NodeConfigAdditionAckList->list.size = e2NodeConfigAdditionAckList->list.count * sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t*);
1373 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
1374 if(e2NodeConfigAdditionAckList->list.array == NULLP)
1376 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
1380 for(arrIdx = 0; arrIdx< e2NodeConfigAdditionAckList->list.count; arrIdx++)
1382 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
1383 if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
1385 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
1388 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[arrIdx];
1389 e2NodeAddAckItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
1390 e2NodeAddAckItemIe->criticality = CriticalityE2_reject;
1391 e2NodeAddAckItemIe->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_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, uint16_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 cmLListDelFrm(&ricSubsDb->actionSequence, actionNode);
2000 deleteActionSequence(actionNode);
2005 /*******************************************************************
2007 * @brief Free Event Trigger Definition
2011 * Function : FreeEventTriggerDef
2013 * Functionality: Free Event Trigger Definition
2015 * @params[in] E2SM-KPM Event Trigger Definition
2018 * ****************************************************************/
2019 void FreeEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
2023 switch(eventTiggerDef->eventDefinition_formats.present)
2025 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
2027 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
2028 RIC_FREE(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1, \
2029 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
2035 /*******************************************************************
2037 * @brief Fill Event Trigger Definition
2041 * Function : fillEventTriggerDef
2043 * Functionality: Fill Event Trigger Definition
2045 * @params[in] RIC Event Trigger Definition
2049 * ****************************************************************/
2050 uint8_t fillEventTriggerDef(RICeventTriggerDefinition_t *ricEventTriggerDef)
2052 uint8_t ret = RFAILED;
2053 asn_enc_rval_t encRetVal;
2054 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef;
2058 /* Fill E2SM-KPM Event Trigger Definition Format 1 */
2059 eventTiggerDef.eventDefinition_formats.present = \
2060 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1;
2062 RIC_ALLOC(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1, \
2063 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
2064 if(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1 == NULLP)
2066 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2070 eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod = 1000; /* In ms */
2072 /* Prints the Msg formed */
2073 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, &eventTiggerDef);
2075 /* Encode E2SM-KPM Event Trigger Definition */
2076 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2078 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_EventTriggerDefinition, 0, &eventTiggerDef, PrepFinalEncBuf, encBuf);
2079 if(encRetVal.encoded == ENCODE_FAIL)
2081 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM event trigger definition structure (at %s)\n",\
2082 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2086 /* Copy encoded E2SM-KPM event trigger definition to E2AP octet string buffer */
2087 ricEventTriggerDef->size = encBufSize;
2088 RIC_ALLOC(ricEventTriggerDef->buf, encBufSize);
2089 if(ricEventTriggerDef->buf == NULLP)
2091 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2094 memcpy(ricEventTriggerDef->buf, encBuf, encBufSize);
2100 FreeEventTriggerDef(&eventTiggerDef);
2104 /*******************************************************************
2106 * @brief builds RIC Subscription Details
2110 * Function : BuildsRicSubsDetails
2112 * Functionality: Builds the RIC Subscription Details
2114 * @params[in] RIC Subscription details to be filled
2115 * RIC subscriotion DB
2116 * @return ROK - success
2119 * ****************************************************************/
2121 uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails, RicSubscription *ricSubsInfo)
2123 uint8_t elementCnt = 0;
2124 uint8_t elementIdx = 0;
2126 if(subsDetails == NULLP)
2128 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2134 /* RIC Event Trigger Definition */
2135 if(fillEventTriggerDef(&subsDetails->ricEventTriggerDefinition) != ROK)
2137 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2141 /* RIC Actions To Be Setup List */
2143 subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
2144 subsDetails->ricAction_ToBeSetup_List.list.size = elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t *);
2145 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
2146 if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
2148 DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
2152 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
2154 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t));
2155 if(!subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
2157 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2161 if(elementIdx < elementCnt)
2166 if(fillActionToBeSetup((RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], \
2167 ricSubsInfo) != ROK)
2169 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2178 /*******************************************************************
2180 * @brief Builds and Send the RicSubscriptionReq
2184 * Function : BuildAndSendRicSubscriptionReq
2186 * Functionality:Fills the RicSubscriptionReq
2188 * @return ROK - success
2191 ******************************************************************/
2192 uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb)
2194 uint8_t ret = RFAILED;
2195 uint8_t elementCnt = 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 cmLListDelFrm(&ricSubs->actionSequence, actionNode);
2441 deleteActionSequence(actionNode);
2454 /*******************************************************************
2456 * @brief deallocate the memory allocated in E2SetupFailure
2460 * Function : FreeE2SetupFailure
2462 * Functionality: deallocate the memory allocated in E2SetupFailure
2464 * @params[in] E2AP_PDU_t *e2apMsg
2467 * ****************************************************************/
2468 void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg)
2471 E2setupFailure_t *e2SetupFail;
2475 if(e2apMsg->choice.unsuccessfulOutcome)
2477 e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
2478 if(e2SetupFail->protocolIEs.list.array)
2480 for(arrIdx=0; arrIdx<e2SetupFail->protocolIEs.list.count; arrIdx++)
2482 RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t));
2484 RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size);
2486 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
2488 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2492 /*******************************************************************
2494 * @brief Buld and send the E2 Setup failure
2498 * Function : BuildAndSendE2SetupFailure
2501 * - Buld and send the E2 Setup failure
2502 * @return ROK - success
2505 * ****************************************************************/
2507 uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint16_t transId)
2509 uint8_t ret = RFAILED;
2510 E2AP_PDU_t *e2apMsg = NULL;
2511 E2setupFailure_t *e2SetupFailure;
2512 asn_enc_rval_t encRetVal;
2515 bool memAllocFailed = false;
2517 DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
2520 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2521 if(e2apMsg == NULLP)
2523 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2526 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
2527 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
2528 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
2530 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2534 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
2535 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
2536 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure;
2537 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
2540 e2SetupFailure->protocolIEs.list.count = elementCnt;
2541 e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *);
2543 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
2544 if(e2SetupFailure->protocolIEs.list.array == NULLP)
2546 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2550 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2552 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
2553 if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
2555 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2556 memAllocFailed = true;
2561 if(memAllocFailed == true)
2563 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2569 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2570 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2571 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
2572 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2575 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
2576 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2577 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
2578 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol;
2579 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified;
2582 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
2583 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
2584 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
2585 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
2587 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2588 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2590 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2592 /* Check encode results */
2593 if(encRetVal.encoded == ENCODE_FAIL)
2595 DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
2596 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2601 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
2602 for(int i=0; i< encBufSize; i++)
2604 DU_LOG("%x",encBuf[i]);
2608 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2610 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
2618 FreeE2SetupFailure(e2apMsg);
2622 /*******************************************************************
2624 * @brief process the e2setup request
2628 * Function : ProcE2SetupReq
2630 * Functionality: process the e2setup request
2634 ******************************************************************/
2636 void ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
2638 uint8_t arrIdx = 0, duIdx = 0;
2639 uint16_t transId =0;
2640 uint16_t ranFuncIdx=0, e2NodeAddListIdx =0;
2641 E2NodeConfigList tmpE2NodeList;
2643 E2nodeComponentConfigAddition_List_t *e2NodeAddList=NULLP;
2644 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem=NULLP;
2645 RANfunction_ItemIEs_t *ranFuncItemIe=NULLP;
2646 RANfunction_Item_t *ranFunItem=NULLP;
2647 RANfunctions_List_t *ranFunctionsList=NULLP;
2649 memset(&tmpE2NodeList, 0, sizeof(E2NodeConfigList));
2652 DU_LOG("\nERROR --> E2AP : e2SetupReq pointer is null");
2655 if(!e2SetupReq->protocolIEs.list.array)
2657 DU_LOG("\nERROR --> E2AP : e2SetupReq array pointer is null");
2661 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
2663 if(e2SetupReq->protocolIEs.list.array[arrIdx])
2665 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
2667 case ProtocolIE_IDE2_id_TransactionID:
2669 transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2672 case ProtocolIE_IDE2_id_GlobalE2node_ID:
2674 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID)
2676 *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0];
2678 SEARCH_DU_DB(duIdx, *duId, duDb);
2681 duDb = &ricCb.duInfo[ricCb.numDu];
2684 memset(duDb, 0, sizeof(DuDb));
2689 case ProtocolIE_IDE2_id_RANfunctionsAdded:
2691 ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2693 if(ranFunctionsList->list.array)
2695 for(ranFuncIdx=0;ranFuncIdx<ranFunctionsList->list.count; ranFuncIdx++)
2697 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
2698 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2699 duDb->ranFunction[ranFunItem->ranFunctionID-1].id = ranFunItem->ranFunctionID;
2700 duDb->ranFunction[ranFunItem->ranFunctionID-1].revisionCounter = ranFunItem->ranFunctionRevision;
2701 cmLListInit(&duDb->ranFunction[ranFunItem->ranFunctionID-1].subscriptionList);
2702 duDb->numOfRanFunction++;
2707 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
2709 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
2710 if(e2NodeAddList->list.array)
2712 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
2714 if(e2NodeAddList->list.array[e2NodeAddListIdx])
2716 /* Storing the E2 node information in DB */
2717 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *)e2NodeAddList->list.array[e2NodeAddListIdx];
2718 if(handleE2NodeComponentAction(duDb, (PTR)&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item,\
2719 ProtocolIE_IDE2_id_E2nodeComponentConfigAddition, &tmpE2NodeList.addedE2Node[tmpE2NodeList.addedE2NodeCount++]) != ROK)
2721 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",e2NodeAddListIdx);
2735 if(BuildAndSendE2SetupRsp(duDb, transId, tmpE2NodeList) !=ROK)
2737 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
2740 /*******************************************************************
2742 * @brief Deallocate the memory allocated for E2 Reset Response
2746 * Function : FreeE2ResetResponse
2749 * - freeing the memory allocated for E2ResetResponse
2751 * @params[in] E2AP_PDU_t *e2apMsg
2752 * @return ROK - success
2755 * ****************************************************************/
2756 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
2759 ResetResponseE2_t *resetResponse =NULLP;
2761 if(e2apMsg != NULLP)
2763 if(e2apMsg->choice.successfulOutcome != NULLP)
2765 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
2766 if(resetResponse->protocolIEs.list.array)
2768 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
2770 if(resetResponse->protocolIEs.list.array[ieIdx])
2772 RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
2775 RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
2777 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2779 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2783 /*******************************************************************
2785 * @brief Buld and send the Reset Response msg
2789 * Function : BuildAndSendResetResponse
2792 * - Buld and send the Reset Response Message
2797 * @return ROK - success
2800 * ****************************************************************/
2801 uint8_t BuildAndSendResetResponse(uint32_t duId, uint16_t transId)
2803 uint8_t ieIdx = 0, elementCnt = 0;
2804 uint8_t ret = RFAILED;
2805 E2AP_PDU_t *e2apMsg = NULLP;
2806 ResetResponseE2_t *resetResponse=NULL;
2807 asn_enc_rval_t encRetVal; /* Encoder return value */
2809 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
2812 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2813 if(e2apMsg == NULLP)
2815 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
2818 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
2820 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2821 if(e2apMsg->choice.successfulOutcome == NULLP)
2823 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
2827 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
2828 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2829 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
2830 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
2833 resetResponse->protocolIEs.list.count = elementCnt;
2834 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
2835 RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
2836 if(!resetResponse->protocolIEs.list.array)
2838 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
2842 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
2844 RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
2845 if(!resetResponse->protocolIEs.list.array[ieIdx])
2847 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
2851 if(ieIdx < elementCnt)
2855 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2856 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
2857 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
2858 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
2860 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2862 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2864 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2865 if(encRetVal.encoded == ENCODE_FAIL)
2867 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
2868 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2873 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
2874 for(int i=0; i< encBufSize; i++)
2876 DU_LOG("%x",encBuf[i]);
2881 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2883 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
2891 FreeE2ResetResponse(e2apMsg);
2895 /*******************************************************************
2897 * @brief deallocate the memory allocated in building the
2898 * Service Query message
2902 * Function : FreeRicServiceQuery
2904 * Functionality: deallocate the memory allocated in building
2905 * Ric Service Query message
2907 * @params[in] E2AP_PDU_t *e2apMsg
2910 * ****************************************************************/
2912 void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg)
2914 uint8_t arrIdx = 0, ranFuncIdx=0;
2915 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
2916 RICserviceQuery_t *ricServiceQuery=NULL;
2920 if(e2apMsg->choice.initiatingMessage)
2922 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
2923 if(ricServiceQuery->protocolIEs.list.array)
2925 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
2927 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
2929 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
2931 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2933 ranFuncAcceptedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2934 if(ranFuncAcceptedList->list.array)
2936 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
2938 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
2940 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
2944 case RICserviceQuery_IEs__value_PR_TransactionID:
2949 RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
2952 RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
2954 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2956 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2960 /*******************************************************************
2962 * @brief build and send the ric service Query
2966 * Function : BuildAndSendRicServiceQuery
2968 * Functionality: build and send the ric service Query
2969 * @return ROK - success
2970 * RFAILED - Acknowledge
2972 ******************************************************************/
2974 uint8_t BuildAndSendRicServiceQuery(DuDb *duDb)
2978 uint8_t ret = RFAILED;
2979 bool memAllocFailed = false;
2980 E2AP_PDU_t *e2apMsg = NULL;
2981 asn_enc_rval_t encRetVal;
2982 RICserviceQuery_t *ricServiceQuery;
2984 DU_LOG("\nINFO --> E2AP : Building Ric service Query\n");
2987 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2988 if(e2apMsg == NULLP)
2990 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2993 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2994 RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2));
2995 if(e2apMsg->choice.initiatingMessage == NULLP)
2997 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3001 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery;
3002 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
3003 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery;
3004 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
3007 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
3008 if(duDb->numOfRanFunction)
3011 ricServiceQuery->protocolIEs.list.count = elementCnt;
3012 ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*);
3014 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
3015 if(ricServiceQuery->protocolIEs.list.array == NULLP)
3017 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
3021 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3023 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
3024 if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP)
3026 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
3027 memAllocFailed = true;
3031 if(memAllocFailed == true)
3033 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
3039 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3040 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3041 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID;
3042 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb);
3044 if(duDb->numOfRanFunction)
3046 /* Accepted RAN function Id */
3048 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
3049 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3050 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List;
3051 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK)
3053 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
3058 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3059 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3061 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3063 /* Check encode results */
3064 if(encRetVal.encoded == ENCODE_FAIL)
3066 DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
3067 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3072 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
3073 for(int i=0; i< encBufSize; i++)
3075 DU_LOG("%x",encBuf[i]);
3079 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
3081 DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed");
3088 FreeRicServiceQuery(e2apMsg);
3092 /*******************************************************************
3094 * @brief deallocate the memory allocated in RicServiceUpdateFailure
3098 * Function : FreeRicServiceUpdateFailure
3100 * Functionality: deallocate the memory allocated in RicServiceUpdatefailure
3102 * @params[in] E2AP_PDU_t *e2apMsg
3105 * ****************************************************************/
3107 void FreeRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
3110 RICserviceUpdateFailure_t *ricServiceUpdateFailure=NULL;
3114 if(e2apMsg->choice.unsuccessfulOutcome)
3116 ricServiceUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
3117 if(ricServiceUpdateFailure->protocolIEs.list.array)
3119 for(arrIdx=0; arrIdx<ricServiceUpdateFailure->protocolIEs.list.count; arrIdx++)
3121 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
3123 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array, ricServiceUpdateFailure->protocolIEs.list.size);
3125 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3127 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3131 /*******************************************************************
3133 * @brief build and send the ric service update failure
3137 * Function : BuildAndSendRicServiceUpdateFailure
3139 * Functionality: build and send the ric service update failure
3140 * @return ROK - success
3143 ******************************************************************/
3145 uint8_t BuildAndSendRicServiceUpdateFailure(uint32_t duId, uint16_t transId, CauseE2_PR causePresent, uint8_t reason)
3148 E2AP_PDU_t *e2apMsg = NULL;
3149 asn_enc_rval_t encRetVal;
3150 uint8_t ret = RFAILED;
3152 uint8_t elementCnt=0;
3153 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
3155 DU_LOG("\nINFO --> E2AP : Building Ric service update failure\n");
3158 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3159 if(e2apMsg == NULLP)
3161 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3164 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3165 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
3166 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3168 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3172 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
3173 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3174 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure;
3175 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
3178 ricServiceFailure->protocolIEs.list.count = elementCnt;
3179 ricServiceFailure->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateFailure_IEs_t *);
3181 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array, ricServiceFailure->protocolIEs.list.size);
3182 if(ricServiceFailure->protocolIEs.list.array == NULLP)
3184 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3188 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3190 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
3191 if(ricServiceFailure->protocolIEs.list.array[arrIdx] == NULLP)
3193 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3197 if(arrIdx<elementCnt)
3199 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3205 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3206 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3207 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TransactionID;
3208 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
3211 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
3212 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3213 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_CauseE2;
3214 fillE2FailureCause(&ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, causePresent, reason);
3217 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
3218 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
3219 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TimeToWaitE2;
3220 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
3222 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3223 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3225 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3227 /* Check encode results */
3228 if(encRetVal.encoded == ENCODE_FAIL)
3230 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\
3231 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3236 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n");
3237 for(int i=0; i< encBufSize; i++)
3239 DU_LOG("%x",encBuf[i]);
3243 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
3245 DU_LOG("\nERROR --> E2AP : Sending RIC service update failed");
3252 FreeRicServiceUpdateFailure(e2apMsg);
3257 /*******************************************************************
3259 * @brief deallocate the memory allocated in RicServiceUpdateAck(
3263 * Function : FreeRicServiceUpdateAck
3265 * Functionality: deallocate the memory allocated in RicServiceUpdateAck
3267 * @params[in] E2AP_PDU_t *e2apMsg
3270 * ****************************************************************/
3272 void FreeRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
3274 uint8_t arrIdx = 0, ranFuncIdx=0;
3275 RANfunctionsID_List_t *acceptedList=NULL;
3276 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
3277 RANfunctionsIDcause_List_t *rejectedList=NULL;
3281 if(e2apMsg->choice.successfulOutcome)
3283 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
3284 if(ricServiceUpdateAck->protocolIEs.list.array)
3286 for(arrIdx=0; arrIdx<ricServiceUpdateAck->protocolIEs.list.count; arrIdx++)
3288 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx])
3290 switch(ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id)
3292 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
3294 acceptedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3295 if(acceptedList->list.array)
3297 for(ranFuncIdx=0;ranFuncIdx<acceptedList->list.count; ranFuncIdx++)
3299 RIC_FREE(acceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
3301 RIC_FREE(acceptedList->list.array, acceptedList->list.size);
3306 case ProtocolIE_IDE2_id_RANfunctionsRejected:
3308 rejectedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
3309 if(rejectedList->list.array)
3311 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
3313 RIC_FREE(rejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
3315 RIC_FREE(rejectedList->list.array, rejectedList->list.size);
3320 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
3323 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
3325 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
3327 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3331 /*******************************************************************
3333 * @brief Build RAN function rejected list
3337 * Function : BuildRanFunctionRejectedList
3339 * Functionality: Build RAN function rejected list
3342 * Count of ran functions to be rejected in the list
3343 * Received list of RAN functions
3345 * @return ROK - success
3347 * ****************************************************************/
3349 uint8_t BuildRanFunctionRejectedList(uint8_t count, RanFunction *ranFunRejectedList, RANfunctionsIDcause_List_t *ranFuncRejectedList)
3351 uint8_t ranFuncIdx = 0;
3352 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
3354 ranFuncRejectedList->list.count = count;
3356 ranFuncRejectedList->list.size = ranFuncRejectedList->list.count*sizeof(RANfunctionIDcause_ItemIEs_t*);
3357 RIC_ALLOC(ranFuncRejectedList->list.array, ranFuncRejectedList->list.size);
3358 if(ranFuncRejectedList->list.array == NULLP)
3360 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array");
3364 for(ranFuncIdx = 0; ranFuncIdx< ranFuncRejectedList->list.count; ranFuncIdx++)
3366 RIC_ALLOC(ranFuncRejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
3367 if(ranFuncRejectedList->list.array[ranFuncIdx] == NULLP)
3369 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array item");
3372 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[ranFuncIdx];
3373 ranFuncRejectedItemIe->id = ProtocolIE_IDE2_id_RANfunctionIEcause_Item;
3374 ranFuncRejectedItemIe->criticality= CriticalityE2_ignore;
3375 ranFuncRejectedItemIe->value.present = RANfunctionIDcause_ItemIEs__value_PR_RANfunctionIDcause_Item;
3376 ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID = ranFunRejectedList[ranFuncIdx].id;
3377 fillE2FailureCause(&ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.cause, CauseE2_PR_ricService,\
3378 CauseE2RICservice_ran_function_not_supported);
3384 /*******************************************************************
3386 * @brief build and send the ric service update Acknowledge
3390 * Function : BuildAndSendRicServiceUpdateAcknowledge
3392 * Functionality: build and send the ric service update Acknowledge
3393 * @return ROK - success
3394 * RFAILED - Acknowledge
3396 ******************************************************************/
3398 uint8_t BuildAndSendRicServiceUpdateAcknowledge(DuDb *duDb, uint16_t transId, RicTmpRanFunList ricRanFuncList)
3400 E2AP_PDU_t *e2apMsg = NULL;
3401 asn_enc_rval_t encRetVal;
3402 uint8_t arrIdx=0, elementCnt=0, ret=RFAILED;;
3403 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
3405 DU_LOG("\nINFO --> E2AP : Building Ric service update Acknowledge\n");
3408 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3409 if(e2apMsg == NULLP)
3411 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3414 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
3415 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(struct SuccessfulOutcomeE2));
3416 if(e2apMsg->choice.successfulOutcome == NULLP)
3418 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3422 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
3423 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
3424 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge;
3425 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
3428 if(ricRanFuncList.numOfRanFunAccepted)
3430 if(ricRanFuncList.numOfRanFuneRejected)
3434 ricServiceUpdateAck->protocolIEs.list.count = elementCnt;
3435 ricServiceUpdateAck->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateAcknowledge_IEs_t*);
3437 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
3438 if(ricServiceUpdateAck->protocolIEs.list.array == NULLP)
3440 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3444 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3446 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
3447 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
3449 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3453 if(arrIdx<elementCnt)
3455 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3461 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3462 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3463 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_TransactionID;
3464 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
3466 if(ricRanFuncList.numOfRanFunAccepted)
3468 /* Accepted RAN function List */
3470 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
3471 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3472 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsID_List;
3473 if(BuildRanFunctionAcceptedList(duDb, ricRanFuncList.numOfRanFunAccepted, ricRanFuncList.ranFunAcceptedList,\
3474 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceUpdate)!=ROK)
3476 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
3481 if(ricRanFuncList.numOfRanFuneRejected)
3483 /* RAN Functions Rejected List */
3485 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsRejected;
3486 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3487 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsIDcause_List;
3488 if(BuildRanFunctionRejectedList(ricRanFuncList.numOfRanFuneRejected, ricRanFuncList.ranFunRejectedList, \
3489 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List)!=ROK)
3491 DU_LOG("\nERROR --> E2AP : Failed to build Ran function rejected list");
3497 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3498 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3500 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3502 /* Check encode results */
3503 if(encRetVal.encoded == ENCODE_FAIL)
3505 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\
3506 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3511 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\n");
3512 for(int i=0; i< encBufSize; i++)
3514 DU_LOG("%x",encBuf[i]);
3518 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
3520 DU_LOG("\nERROR --> E2AP : Sending RIC service update ack failed");
3526 FreeRicServiceUpdateAck(e2apMsg);
3530 /*******************************************************************
3532 * @brief process the RIC service update
3536 * Function : ProcRicserviceUpdate
3538 * Functionality: process the RIC service update
3540 * @return ROK - success
3543 ******************************************************************/
3545 void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate)
3547 RicTmpRanFunList ricRanFuncList;
3550 uint8_t duIdx = 0, elementCnt =0, arrIdx = 0;
3551 uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0;
3552 RanFunction *ranFuncDb = NULLP;
3553 RANfunction_ItemIEs_t *ranFuncItemIe =NULL;
3554 RANfunction_Item_t *ranFuncItem =NULL;
3555 RANfunctionID_Item_t *ranFuncIdItem=NULL;
3556 RANfunctions_List_t *ranFuncList=NULL;
3557 RANfunctionsID_List_t *deleteList=NULL;
3558 RANfunctionID_ItemIEs_t *delRanFuncItem=NULL;
3560 SEARCH_DU_DB(duIdx, duId, duDb);
3563 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
3566 memset(&ricRanFuncList, 0, sizeof(RicTmpRanFunList));
3568 if(!ricServiceUpdate)
3570 DU_LOG("\nERROR --> E2AP : ricServiceUpdate pointer is null");
3574 if(!ricServiceUpdate->protocolIEs.list.array)
3576 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array pointer is null");
3579 elementCnt = ricServiceUpdate->protocolIEs.list.count;
3580 for(arrIdx=0; arrIdx<ricServiceUpdate->protocolIEs.list.count; arrIdx++)
3582 if(!ricServiceUpdate->protocolIEs.list.array[arrIdx])
3584 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx);
3588 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
3590 case ProtocolIE_IDE2_id_TransactionID:
3592 transId = ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
3594 if(transId < 0 || transId > 255)
3596 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
3602 case ProtocolIE_IDE2_id_RANfunctionsAdded:
3604 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
3606 if(ranFuncList->list.array)
3608 for(ranFuncIdx=0;ranFuncIdx<ranFuncList->list.count; ranFuncIdx++)
3610 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
3611 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
3613 /* Adding the ran function in temporary list */
3614 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
3615 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
3616 ricRanFuncList.numOfRanFunAccepted++;
3618 /* Adding the new ran function in DB*/
3619 duDb->ranFunction[ranFuncItem->ranFunctionID-1].id = ranFuncItem->ranFunctionID;
3620 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
3621 duDb->numOfRanFunction++;
3623 /* Calculating total number of ran fuctions which are received for addition */
3624 recvdRanFuncCount++;
3630 case ProtocolIE_IDE2_id_RANfunctionsModified:
3633 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
3634 if(ranFuncList->list.array)
3636 for(ranFuncIdx = 0; ranFuncIdx< ranFuncList->list.count; ranFuncIdx++)
3638 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
3639 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
3640 if(fetchRanFuncFromRanFuncId(duDb, ranFuncItem->ranFunctionID) == NULLP)
3642 /* Calculating total number of ran fuctions which are not present */
3643 failedRanFuncCount++;
3645 /* Adding the ran function in temporary list */
3646 ricRanFuncList.ranFunRejectedList[ricRanFuncList.numOfRanFuneRejected].id = ranFuncItem->ranFunctionID;
3647 ricRanFuncList.numOfRanFuneRejected++;
3652 /* Adding the ran function in temporary list */
3653 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
3654 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
3655 ricRanFuncList.numOfRanFunAccepted++;
3657 /* Updating the new ran function in DB*/
3658 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
3660 /* Calculating total number of ran fuctions which are received for modification */
3661 recvdRanFuncCount++;
3666 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
3669 deleteList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3670 if(deleteList->list.array)
3672 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
3674 delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx];
3675 ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item;
3676 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncIdItem->ranFunctionID);
3679 memset(ranFuncDb, 0, sizeof(RanFunction));
3680 duDb->numOfRanFunction--;
3683 /* Calculating total number of ran fuctions which are received for deletion */
3684 recvdRanFuncCount++;
3692 DU_LOG("\nERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id);
3698 /* Sending RIC Service Update Failed if all RAN Functions received fail or if any IE processing fails
3699 * Else sending RIC Service Update Acknowledge */
3700 if((elementCnt > arrIdx) ||((recvdRanFuncCount > 0) && (recvdRanFuncCount == failedRanFuncCount)))
3702 if(BuildAndSendRicServiceUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
3704 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update Failure");
3710 if(BuildAndSendRicServiceUpdateAcknowledge(duDb, transId, ricRanFuncList) != ROK)
3712 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update acknowledge");
3718 /*******************************************************************
3720 * @brief Processing RIC subscription failure from DU
3724 * Function : ProcRicSubscriptionFailure
3726 * Functionality: Processing RIC subscription failure from DU
3728 * @param ID of DU from which message was sent
3729 * RIC Subscription failure message
3730 * @return ROK - success
3733 ******************************************************************/
3734 uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricSubscriptionFailure)
3736 uint8_t ieIdx = 0, duIdx = 0;
3737 uint8_t ranFuncId = 0;
3739 RanFunction *ranFuncDb = NULLP;
3740 RicSubscription *ricSubs = NULLP;
3741 CmLList *ricSubsNode = NULLP;
3742 RicRequestId ricReqId;
3743 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3745 DU_LOG("\nINFO --> E2AP : Received RIC subscription failure");
3747 SEARCH_DU_DB(duIdx, duId, duDb);
3750 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
3754 memset(&ricReqId, 0, sizeof(RicRequestId));
3755 if(ricSubscriptionFailure)
3757 if(ricSubscriptionFailure->protocolIEs.list.array)
3759 for(ieIdx=0; ieIdx<ricSubscriptionFailure->protocolIEs.list.count; ieIdx++)
3761 if(ricSubscriptionFailure->protocolIEs.list.array[ieIdx])
3763 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[ieIdx];
3764 switch(ricSubscriptionFailure->protocolIEs.list.array[ieIdx]->id)
3766 case ProtocolIE_IDE2_id_RICrequestID:
3768 ricReqId.requestorId = ricSubsFailIe->value.choice.RICrequestID.ricRequestorID;
3769 ricReqId.instanceId = ricSubsFailIe->value.choice.RICrequestID.ricInstanceID;
3772 case ProtocolIE_IDE2_id_RANfunctionID:
3774 ranFuncId = ricSubsFailIe->value.choice.RANfunctionID;
3775 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
3778 DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId);
3783 /* Remove subscription entry from RAN Function */
3784 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
3787 cmLListDelFrm(&ranFuncDb->subscriptionList, ricSubsNode);
3788 deleteRicSubscriptionNode(ricSubsNode);
3793 case ProtocolIE_IDE2_id_CauseE2:
3795 /* No handling required as of now since this is a stub */
3805 /*******************************************************************
3807 * @brief Free RIC Subscription Modification Refuse
3811 * Function : FreeRicSubsModRefuse
3813 * Functionality: Free RIC Subscription Modification Refuse
3815 * @param E2AP Message PDU to be freed
3818 ******************************************************************/
3819 void FreeRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
3822 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
3826 if(e2apMsg->choice.unsuccessfulOutcome)
3828 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
3829 if(ricSubsModRefuse->protocolIEs.list.array)
3831 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
3833 RIC_FREE(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
3835 RIC_FREE(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
3837 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
3839 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3843 /*******************************************************************
3845 * @brief Build And Send RIC Subscription Modification Refuse
3849 * Function : BuildAndSendRicSubsModRefuse
3851 * Functionality: Build And Send RIC Subscription Modification Refuse
3854 * RIC Request ID of subscription
3858 * @return ROK - success
3861 ******************************************************************/
3862 uint8_t BuildAndSendRicSubsModRefuse(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, CauseE2_PR causeType, \
3865 uint8_t ieIdx = 0, elementCnt = 0;
3866 uint8_t ret = RFAILED;
3867 E2AP_PDU_t *e2apMsg = NULL;
3868 asn_enc_rval_t encRetVal;
3869 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
3870 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
3872 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Refuse\n");
3875 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3876 if(e2apMsg == NULLP)
3878 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3881 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3882 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
3883 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3885 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3889 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
3890 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3891 e2apMsg->choice.unsuccessfulOutcome->value.present = \
3892 UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse;
3893 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
3896 ricSubsModRefuse->protocolIEs.list.count = elementCnt;
3897 ricSubsModRefuse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRefuse_IEs_t *);
3898 RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
3899 if(!ricSubsModRefuse->protocolIEs.list.array)
3901 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3905 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
3907 RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
3908 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
3910 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3915 /* RIC Request ID */
3917 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3918 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RICrequestID;
3919 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3920 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RICrequestID;
3921 ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3922 ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3924 /* RAN Function ID */
3926 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3927 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3928 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3929 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RANfunctionID;
3930 ricSubsModRefuseIe->value.choice.RANfunctionID = ranFuncId;
3934 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3935 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_CauseE2;
3936 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3937 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_CauseE2;
3938 fillE2FailureCause(&ricSubsModRefuseIe->value.choice.CauseE2, causeType, cause);
3940 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3941 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3943 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3945 /* Check encode results */
3946 if(encRetVal.encoded == ENCODE_FAIL)
3948 DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification refuse (at %s)\n",\
3949 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3954 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification refuse\n");
3955 for(int i=0; i< encBufSize; i++)
3957 DU_LOG("%x",encBuf[i]);
3961 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
3963 DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Refused");
3970 FreeRicSubsModRefuse(e2apMsg);
3974 /*******************************************************************
3976 * @brief Free memory for RIC Subscription Modification Confirm
3980 * Function : FreeRicSubsModConfirm
3982 * Functionality: Free memory for RIC subscription modification
3985 * @param E2AP Message PDU to be freed
3988 ******************************************************************/
3989 void FreeRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
3991 uint8_t ieIdx = 0, arrIdx=0;
3992 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
3993 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
3994 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
3995 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
3996 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
3997 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
4001 if(e2apMsg->choice.successfulOutcome)
4003 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
4004 if(ricSubsModCfm->protocolIEs.list.array)
4006 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
4008 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
4010 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4011 switch(ricSubsModCfmIe->id)
4013 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
4015 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
4016 if(modCfmList->list.array)
4018 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
4020 RIC_FREE(modCfmList->list.array[arrIdx], \
4021 sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
4023 RIC_FREE(modCfmList->list.array, modCfmList->list.size);
4028 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
4030 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
4031 if(modRefusedList->list.array)
4033 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
4035 RIC_FREE(modRefusedList->list.array[arrIdx], \
4036 sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
4038 RIC_FREE(modRefusedList->list.array, modRefusedList->list.size);
4043 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
4045 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
4046 if(rmvCfmList->list.array)
4048 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
4050 RIC_FREE(rmvCfmList->list.array[arrIdx], \
4051 sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
4053 RIC_FREE(rmvCfmList->list.array, rmvCfmList->list.size);
4058 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
4060 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
4061 if(rmvFailList->list.array)
4063 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
4065 RIC_ALLOC(rmvFailList->list.array[arrIdx], \
4066 sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
4068 RIC_FREE(rmvFailList->list.array, rmvFailList->list.size);
4077 RIC_FREE(ricSubsModCfmIe, sizeof(RICsubscriptionModificationConfirm_IEs_t));
4080 RIC_FREE(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
4082 RIC_FREE(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
4084 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4088 /*******************************************************************
4090 * @brief Fill the list of actions confirmed for modification
4094 * Function : fillActionModConfirmedList
4096 * Functionality: Fill the list of actions confirmed for modification
4098 * @param List to be filled
4100 * Source list of actions
4101 * @return ROK - success
4104 ******************************************************************/
4105 uint8_t fillActionModConfirmedList(RICactions_ConfirmedForModification_List_t *modCfmList, uint8_t numActions, \
4106 uint8_t *actionModifiedList)
4109 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
4111 modCfmList->list.count = numActions;
4112 modCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForModification_ItemIEs_t *);
4113 RIC_ALLOC(modCfmList->list.array, modCfmList->list.size);
4114 if(!modCfmList->list.array)
4116 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4120 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
4122 RIC_ALLOC(modCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
4123 if(!modCfmList->list.array[arrIdx])
4125 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4129 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
4130 modCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForModification_Item;
4131 modCfmListItem->criticality = CriticalityE2_ignore;
4132 modCfmListItem->value.present = \
4133 RICaction_ConfirmedForModification_ItemIEs__value_PR_RICaction_ConfirmedForModification_Item;
4134 modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID = actionModifiedList[arrIdx];
4140 /*******************************************************************
4142 * @brief Fill the list of actions refused to be modified
4146 * Function : fillActionModRefusedList
4148 * Functionality: Fill the list of actions refused to be modified
4150 * @param List to be filled
4152 * Source list of actions refused tobe modified
4153 * @return ROK - success
4156 ******************************************************************/
4157 uint8_t fillActionModRefusedList(RICactions_RefusedToBeModified_List_t *modRefusedList, uint8_t numActions, \
4158 ActionFailed *actionModFailedList)
4161 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
4163 modRefusedList->list.count = numActions;
4164 modRefusedList->list.size = numActions * sizeof(RICaction_RefusedToBeModified_ItemIEs_t *);
4165 RIC_ALLOC(modRefusedList->list.array, modRefusedList->list.size);
4166 if(!modRefusedList->list.array)
4168 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4172 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
4174 RIC_ALLOC(modRefusedList->list.array[arrIdx], sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
4175 if(!modRefusedList->list.array[arrIdx])
4177 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4181 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
4182 modRefusedListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeModified_Item;
4183 modRefusedListItem->criticality = CriticalityE2_ignore;
4184 modRefusedListItem->value.present = \
4185 RICaction_RefusedToBeModified_ItemIEs__value_PR_RICaction_RefusedToBeModified_Item;
4186 modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID = \
4187 actionModFailedList[arrIdx].actionId;
4188 fillE2FailureCause(&modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.cause, \
4189 actionModFailedList[arrIdx].failureType, actionModFailedList[arrIdx].cause);
4195 /*******************************************************************
4197 * @brief Fill the list of action confirmed for removal
4201 * Function : fillActionRemovalConfirmedList
4203 * Functionality: Fill the list of action confirmed for removal
4205 * @param List to be filled
4207 * Source list of actions removed
4208 * @return ROK - success
4211 ******************************************************************/
4212 uint8_t fillActionRemovalConfirmedList(RICactions_ConfirmedForRemoval_List_t *rmvCfmList, uint8_t numActions, \
4213 uint8_t *actionRemovedList)
4216 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
4218 rmvCfmList->list.count = numActions;
4219 rmvCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t *);
4220 RIC_ALLOC(rmvCfmList->list.array, rmvCfmList->list.size);
4221 if(!rmvCfmList->list.array)
4223 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4227 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
4229 RIC_ALLOC(rmvCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
4230 if(!rmvCfmList->list.array[arrIdx])
4232 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4236 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
4237 rmvCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForRemoval_Item;
4238 rmvCfmListItem->criticality = CriticalityE2_ignore;
4239 rmvCfmListItem->value.present = \
4240 RICaction_ConfirmedForRemoval_ItemIEs__value_PR_RICaction_ConfirmedForRemoval_Item;
4241 rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID = actionRemovedList[arrIdx];
4247 /*******************************************************************
4249 * @brief Fill the list of actions refused to be removed
4253 * Function : fillActionRemovalRefusedList
4255 * Functionality: Fill the list of actions refused to be removed
4257 * @param List to be filled
4259 * Source list of actions refused to be removed
4260 * @return ROK - success
4263 ******************************************************************/
4264 uint8_t fillActionRemovalRefusedList(RICactions_RefusedToBeRemoved_List_t *rmvFailList, \
4265 uint8_t numActions, ActionFailed *actionRmvlFailList)
4268 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
4270 rmvFailList->list.count = numActions;
4271 rmvFailList->list.size = numActions * sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t *);
4272 RIC_ALLOC(rmvFailList->list.array, rmvFailList->list.size);
4273 if(!rmvFailList->list.array)
4275 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4279 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
4281 RIC_ALLOC(rmvFailList->list.array[arrIdx], sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
4282 if(!rmvFailList->list.array[arrIdx])
4284 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4288 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
4289 rmvFailListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeRemoved_Item;
4290 rmvFailListItem->criticality = CriticalityE2_ignore;
4291 rmvFailListItem->value.present = \
4292 RICaction_RefusedToBeRemoved_ItemIEs__value_PR_RICaction_RefusedToBeRemoved_Item;
4293 rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID = actionRmvlFailList[arrIdx].actionId;
4294 fillE2FailureCause(&rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.cause, \
4295 actionRmvlFailList[arrIdx].failureType, actionRmvlFailList[arrIdx].cause);
4302 /*******************************************************************
4304 * @brief Build And Send RIC Subscription Modification Confirm
4308 * Function : BuildAndSendRicSubsModConfirm
4310 * Functionality: Build And Send RIC Subscription Modification Confirm
4313 * RIC Request ID of subscription
4315 * Temporary source action list
4316 * @return ROK - success
4319 ******************************************************************/
4320 uint8_t BuildAndSendRicSubsModConfirm(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, RicTmpActionList tmpActionList)
4322 uint8_t ieIdx = 0, elementCnt = 0;
4323 uint8_t ret = RFAILED;
4324 E2AP_PDU_t *e2apMsg = NULLP;
4325 asn_enc_rval_t encRetVal;
4326 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
4327 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
4329 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Confirm\n");
4332 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4333 if(e2apMsg == NULLP)
4335 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4339 /* Successful Outcome */
4340 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
4341 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
4342 if(e2apMsg->choice.successfulOutcome == NULLP)
4344 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4348 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
4349 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
4350 e2apMsg->choice.successfulOutcome->value.present = \
4351 SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm;
4352 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
4355 if(tmpActionList.numActionModified)
4357 if(tmpActionList.numActionModFailed)
4359 if(tmpActionList.numActionRemoved)
4361 if(tmpActionList.numActionRemovalFailed)
4364 ricSubsModCfm->protocolIEs.list.count = elementCnt;
4365 ricSubsModCfm->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationConfirm_IEs_t *);
4366 RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
4367 if(!ricSubsModCfm->protocolIEs.list.array)
4369 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4373 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
4375 RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationConfirm_IEs_t));
4376 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
4378 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4383 /* RIC Request ID */
4385 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4386 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICrequestID;
4387 ricSubsModCfmIe->criticality = CriticalityE2_reject;
4388 ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RICrequestID;
4389 ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
4390 ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
4392 /* RAN Function ID */
4394 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4395 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RANfunctionID;
4396 ricSubsModCfmIe->criticality = CriticalityE2_reject;
4397 ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RANfunctionID;
4398 ricSubsModCfmIe->value.choice.RANfunctionID = ranFuncId;
4400 /* RIC Actions List confirmed for modification */
4401 if(tmpActionList.numActionModified)
4404 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4405 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List;
4406 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4407 ricSubsModCfmIe->value.present = \
4408 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForModification_List;
4409 if(fillActionModConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List, \
4410 tmpActionList.numActionModified, tmpActionList.actionModifiedList) != ROK)
4412 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Modification List", __func__);
4417 /* RIC Actions List refured to be modified */
4418 if(tmpActionList.numActionModFailed)
4421 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4422 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List;
4423 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4424 ricSubsModCfmIe->value.present = \
4425 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeModified_List;
4426 if(fillActionModRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List, \
4427 tmpActionList.numActionModFailed, tmpActionList.actionModFailedList) != ROK)
4429 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Refused to be Modified List", __func__);
4434 /* RIC Actions List confirmed for removal */
4435 if(tmpActionList.numActionRemoved)
4438 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4439 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List;
4440 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4441 ricSubsModCfmIe->value.present = \
4442 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForRemoval_List;
4443 if(fillActionRemovalConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List, \
4444 tmpActionList.numActionRemoved, tmpActionList.actionRemovedList) != ROK)
4446 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Removal List", __func__);
4451 /* RIC Actions List Refused to be removed */
4452 if(tmpActionList.numActionRemovalFailed)
4455 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4456 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List;
4457 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4458 ricSubsModCfmIe->value.present = \
4459 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeRemoved_List;
4460 if(fillActionRemovalRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List, \
4461 tmpActionList.numActionRemovalFailed, tmpActionList.actionRemovalFailedList) != ROK)
4463 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Failed to be Removed List", __func__);
4468 /* Print and encode E2AP Message PDU */
4469 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4470 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4472 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
4474 /* Check encode results */
4475 if(encRetVal.encoded == ENCODE_FAIL)
4477 DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification confirm (at %s)\n",\
4478 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4483 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification confirm\n");
4484 for(int i=0; i< encBufSize; i++)
4486 DU_LOG("%x",encBuf[i]);
4490 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
4492 DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Confirm");
4500 FreeRicSubsModConfirm(e2apMsg);
4504 /*******************************************************************
4506 * @brief Processing of RIC Subscription Modification Required
4510 * Function : ProcRicSubsModReqd
4512 * Functionality: Processing of RIC Subscription Modification Required
4513 * As of now, we do not identify any scenario where this message
4514 * shall be sent by DU. Hence, bare minimum handling has been
4518 * RIC Subscription Modification Required IEs
4519 * @return ROK-success
4522 ******************************************************************/
4523 uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t *ricSubsModReqd)
4525 uint8_t ieIdx = 0, actionIdx = 0, duIdx = 0;
4529 RicRequestId ricReqId;
4530 RanFunction *ranFuncDb = NULLP;
4531 RicSubscription *ricSubs = NULLP;
4532 CmLList *ricSubsNode = NULLP;
4533 CmLList *actionNode = NULLP;
4534 ActionInfo *action = NULLP;
4535 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
4536 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
4537 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
4538 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULLP;
4539 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULLP;
4540 RicTmpActionList tmpActionList;
4542 memset(&ricReqId, 0, sizeof(RicRequestId));
4543 memset(&tmpActionList, 0, sizeof(RicTmpActionList));
4545 SEARCH_DU_DB(duIdx, duId, duDb);
4548 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
4552 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
4554 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
4555 switch(ricSubsModReqdIe->id)
4557 case ProtocolIE_IDE2_id_RICrequestID:
4559 ricReqId.requestorId = ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID;
4560 ricReqId.instanceId = ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID;
4563 case ProtocolIE_IDE2_id_RANfunctionID:
4565 ranFuncId = ricSubsModReqdIe->value.choice.RANfunctionID;
4566 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
4569 /* If RIC Subscription not found, send RIC Subscription modification refuse to DU */
4570 DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RIC Subscription not found");
4571 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
4572 CauseE2RICrequest_ran_function_id_invalid);
4576 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
4579 /* If RAN Function not found, send RIC Subscription modification refuse to DU */
4580 DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RAN Function ID [%d] not found",ranFuncId);
4581 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, \
4582 CauseE2_PR_ricRequest, CauseE2RICrequest_request_id_unknown);
4587 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
4589 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
4590 for(actionIdx = 0; actionIdx < actionToBeModList->list.count; actionIdx++)
4593 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[actionIdx];
4594 actionId = actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID;
4595 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
4598 /* No modification required as of now, hence directly adding to the list */
4599 tmpActionList.actionModifiedList[tmpActionList.numActionModified++] = actionId;
4603 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].actionId = actionId;
4604 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].failureType = \
4605 CauseE2_PR_ricRequest;
4606 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].cause = \
4607 CauseE2RICrequest_action_not_supported;
4608 tmpActionList.numActionModFailed++;
4613 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
4615 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
4616 for(actionIdx = 0; actionIdx < actionToBeRmvList->list.count; actionIdx++)
4619 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[actionIdx];
4620 actionId = actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID;
4621 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
4624 tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId;
4625 cmLListDelFrm(&ricSubs->actionSequence, actionNode);
4626 deleteActionSequence(actionNode);
4636 /* If none of the action modification/removal is supported,
4637 * send RIC Subscription Modification Refuse
4639 * send RIC Subscription Modification Confirm
4641 if(tmpActionList.numActionModified || tmpActionList.numActionRemoved)
4643 BuildAndSendRicSubsModConfirm(duId, ricReqId, ranFuncId, tmpActionList);
4647 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
4648 CauseE2RICrequest_action_not_supported);
4654 /*******************************************************************
4656 * @brief Free the ErrorIndication Message
4660 * Function : FreeRicIndication
4662 * Functionality: Free the ErrorIndication Message
4667 ******************************************************************/
4668 void FreeErrorIndication(E2AP_PDU_t *e2apMsg)
4671 ErrorIndicationE2_t *errorIndicationMsg= NULLP;
4673 if(e2apMsg != NULLP)
4675 if(e2apMsg->choice.initiatingMessage != NULLP)
4677 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
4678 if(errorIndicationMsg!= NULLP)
4680 if(errorIndicationMsg->protocolIEs.list.array != NULLP)
4682 for(arrIdx=0; arrIdx<errorIndicationMsg->protocolIEs.list.count; arrIdx++)
4684 RIC_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t));
4686 RIC_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size);
4689 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4691 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4696 /*******************************************************************
4698 * @brief Builds and Send the ErrorIndication Message
4702 * Function : BuildAndSendErrorIndication
4704 * Functionality:Fills the ErrorIndication Message
4712 * @return ROK - success
4715 ******************************************************************/
4717 uint8_t BuildAndSendErrorIndication(uint32_t duId, uint16_t transId, RicRequestId requestId, uint16_t ranFuncId, uint8_t reason)
4719 uint8_t elementCnt =0, arrIdx=0, ret = RFAILED;
4720 E2AP_PDU_t *e2apMsg = NULLP;
4721 ErrorIndicationE2_t *errorIndicationMsg=NULLP;
4722 asn_enc_rval_t encRetVal; /* Encoder return value */
4726 DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
4728 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4729 if(e2apMsg == NULLP)
4731 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
4735 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4736 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4737 if(e2apMsg->choice.initiatingMessage == NULLP)
4739 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
4742 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
4743 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4744 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2;
4746 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
4748 /* Element count is 2 for TransactionID/RICrequestID and Cause.
4749 * If the RAN function id is present, the count will be increased.*/
4754 errorIndicationMsg->protocolIEs.list.count = elementCnt;
4755 errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*);
4757 /* Initialize the E2Setup members */
4758 RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
4759 if(errorIndicationMsg->protocolIEs.list.array == NULLP)
4761 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
4764 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
4766 RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
4767 if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
4769 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array Idx %d in %s at line %d",arrIdx,__func__, __LINE__);
4773 if(arrIdx < elementCnt)
4778 if(transId >=0 && transId<=255)
4781 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4782 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4783 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID;
4784 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4789 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID;
4790 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4791 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID;
4792 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId;
4793 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
4798 /* RAN Function ID */
4800 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID;
4801 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4802 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID;
4803 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId;
4808 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
4809 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
4810 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
4811 fillE2FailureCause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, CauseE2_PR_misc, reason);
4814 /* Prints the Msg formed */
4815 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4816 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4818 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4820 if(encRetVal.encoded == ENCODE_FAIL)
4822 DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
4823 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4828 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
4829 #ifdef DEBUG_ASN_PRINT
4830 for(int i=0; i< encBufSize; i++)
4832 printf("%x",encBuf[i]);
4837 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
4839 DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
4845 FreeErrorIndication(e2apMsg);
4849 /*******************************************************************
4851 * @brief Deallocate the memory allocated for ResetRequest msg
4855 * Function : FreeResetRequest
4858 * - freeing the memory allocated for ResetRequest
4860 * @params[in] E2AP_PDU_t *e2apMsg
4861 * @return ROK - success
4864 * ****************************************************************/
4865 void FreeResetRequest(E2AP_PDU_t *e2apMsg)
4868 ResetRequestE2_t *resetReq = NULLP;
4870 if(e2apMsg != NULLP)
4872 if(e2apMsg->choice.initiatingMessage != NULLP)
4874 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4875 if(resetReq->protocolIEs.list.array)
4877 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
4879 RIC_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4881 RIC_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4883 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4885 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4889 /*******************************************************************
4891 * @brief Build and send the reset request msg
4895 * Function : BuildAndSendResetRequest
4898 * - Buld and send the reset request msg to E2 node
4904 * @return ROK - success
4907 * ****************************************************************/
4908 uint8_t BuildAndSendResetRequest(DuDb *duDb, CauseE2_PR causePresent, uint8_t reason)
4910 uint8_t ieIdx = 0, elementCnt = 0;
4911 uint16_t transId = 0;
4912 uint8_t ret = RFAILED;
4913 E2AP_PDU_t *e2apMsg = NULLP;
4914 ResetRequestE2_t *resetReq = NULLP;
4915 asn_enc_rval_t encRetVal; /* Encoder return value */
4917 DU_LOG("\nINFO --> E2AP : Building Reset Request\n");
4921 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4922 if(e2apMsg == NULLP)
4924 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for E2AP-PDU failed");
4928 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4929 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4930 if(e2apMsg->choice.initiatingMessage == NULLP)
4932 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for initiatingMessage");
4936 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
4937 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4938 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
4939 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4942 resetReq->protocolIEs.list.count = elementCnt;
4943 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
4945 RIC_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4946 if(!resetReq->protocolIEs.list.array)
4948 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
4949 Reset Request IE array");
4953 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
4955 RIC_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4956 if(!resetReq->protocolIEs.list.array[ieIdx])
4958 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
4959 Reset Request IE array element");
4964 /* In case of failure */
4965 if(ieIdx < elementCnt)
4969 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4970 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
4971 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
4972 transId = assignTransactionId(duDb);
4973 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
4976 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
4977 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
4978 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
4979 fillE2FailureCause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
4981 /* Prints the Msg formed */
4982 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4984 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4986 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4988 if(encRetVal.encoded == ENCODE_FAIL)
4990 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
4991 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4996 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
4997 #ifdef DEBUG_ASN_PRINT
4998 for(int i=0; i< encBufSize; i++)
5000 printf("%x",encBuf[i]);
5004 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
5006 DU_LOG("\nERROR --> E2AP : Sending reset request failed");
5015 /* Free all memory */
5016 FreeResetRequest(e2apMsg);
5020 /******************************************************************
5022 * @brief Delete Ric subscription action
5026 * Function : deleteActionSequence
5028 * Functionality: Delete Ric subscription action
5030 * @params[in] Action info
5034 * ****************************************************************/
5035 void deleteActionSequence(CmLList *actionNode)
5037 ActionInfo *action = NULLP;
5041 action = (ActionInfo*)actionNode->node;
5042 memset(action, 0, sizeof(ActionInfo));
5043 RIC_FREE(actionNode->node, sizeof(ActionInfo));
5044 RIC_FREE(actionNode, sizeof(CmLList));
5048 /******************************************************************
5050 * @brief Delete Ric subscription action list
5054 * Function : deleteActionSequenceList
5056 * Functionality: Delete Ric subscription action list
5058 * @params[in] Action info list
5062 * ****************************************************************/
5063 void deleteActionSequenceList(CmLListCp *actionList)
5065 CmLList *actionNode=NULLP;
5067 CM_LLIST_FIRST_NODE(actionList, actionNode);
5070 cmLListDelFrm(actionList, actionNode);
5071 deleteActionSequence(actionNode);
5072 CM_LLIST_FIRST_NODE(actionList, actionNode);
5077 /******************************************************************
5079 * @brief Delete Ric subscription node
5083 * Function : deleteRicSubscriptionNode
5085 * Functionality: Delete Ric subscription node
5087 * @params[in] Ric subscription info
5091 * ****************************************************************/
5092 void deleteRicSubscriptionNode(CmLList *subscriptionNode)
5094 RicSubscription *ricSubscriptionInfo = NULLP;
5096 ricSubscriptionInfo = (RicSubscription*)subscriptionNode->node;
5098 deleteActionSequenceList(&ricSubscriptionInfo->actionSequence);
5100 memset(ricSubscriptionInfo, 0, sizeof(RicSubscription));
5101 RIC_FREE(subscriptionNode->node, sizeof(RicSubscription));
5102 RIC_FREE(subscriptionNode, sizeof(CmLList));
5105 /*******************************************************************
5107 * @brief Delete RIC subscription List
5111 * Function : deleteRicSubscriptionList
5113 * Functionality: Delete RIC subscription list
5115 * @params[in] RIC Subscription list
5119 ******************************************************************/
5120 void deleteRicSubscriptionList(CmLListCp *subscriptionList)
5122 CmLList *subscriptionNode = NULLP;
5124 CM_LLIST_FIRST_NODE(subscriptionList, subscriptionNode);
5125 while(subscriptionNode)
5127 cmLListDelFrm(subscriptionList, subscriptionNode);
5128 deleteRicSubscriptionNode(subscriptionNode);
5129 CM_LLIST_FIRST_NODE(subscriptionList, subscriptionNode);
5133 /*******************************************************************
5135 * @brief process the E2 Reset Response
5139 * Function : ProcResetResponse
5141 * Functionality: Process E2 Reset Response
5145 * Pointer to reset response
5148 ******************************************************************/
5150 void ProcResetResponse(uint32_t duId, ResetResponseE2_t *resetRsp)
5152 uint8_t ieIdx = 0, duIdx =0;
5154 RanFunction *ranFuncDb = NULLP;
5155 uint16_t ranFuncIdx = 0;
5157 SEARCH_DU_DB(duIdx, duId, duDb);
5160 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5166 DU_LOG("\nERROR --> E2AP : resetRsp pointer is null");
5170 if(!resetRsp->protocolIEs.list.array)
5172 DU_LOG("\nERROR --> E2AP : resetRsp array pointer is null");
5176 for(ieIdx=0; ieIdx < resetRsp->protocolIEs.list.count; ieIdx++)
5178 if(resetRsp->protocolIEs.list.array[ieIdx])
5180 switch(resetRsp->protocolIEs.list.array[ieIdx]->id)
5182 case ProtocolIE_IDE2_id_TransactionID:
5184 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
5186 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
5187 if(ranFuncDb->id > 0)
5189 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
5194 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5204 /*******************************************************************
5206 * @brief process the E2 Reset Request
5210 * Function : ProcResetRequest
5212 * Functionality: Process E2 Reset Request
5216 * Pointer to reset response
5219 ******************************************************************/
5221 void ProcResetRequest(uint32_t duId, ResetRequestE2_t *resetReq)
5223 uint8_t ieIdx = 0, duIdx =0;
5226 RanFunction *ranFuncDb = NULLP;
5227 uint16_t ranFuncIdx = 0;
5229 SEARCH_DU_DB(duIdx, duId, duDb);
5232 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5238 DU_LOG("\nERROR --> E2AP : resetReq pointer is null");
5242 if(!resetReq->protocolIEs.list.array)
5244 DU_LOG("\nERROR --> E2AP : resetReq array pointer is null");
5248 for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
5250 if(resetReq->protocolIEs.list.array[ieIdx])
5252 switch(resetReq->protocolIEs.list.array[ieIdx]->id)
5254 case ProtocolIE_IDE2_id_TransactionID:
5256 transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5259 case ProtocolIE_IDE2_id_CauseE2:
5261 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
5263 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
5264 if(ranFuncDb->id > 0)
5266 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
5275 if(BuildAndSendResetResponse(duId, transId) !=ROK)
5277 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
5281 /*******************************************************************
5283 * @brief Free RIC Subscription Delete Request Message
5287 * Function : FreeRicSubscriptionDeleteRequest
5289 * Functionality: Free RIC Subscription Delete Request
5291 * @param E2AP Message PDU
5294 ******************************************************************/
5295 void FreeRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
5298 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
5302 if(e2apMsg->choice.initiatingMessage)
5304 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
5305 if(ricSubsDelReq->protocolIEs.list.array)
5307 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
5309 RIC_FREE(ricSubsDelReq->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
5311 RIC_FREE(ricSubsDelReq->protocolIEs.list.array, ricSubsDelReq->protocolIEs.list.size);
5313 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5315 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
5319 /*******************************************************************
5321 * @brief Builds and Send RIC Subscription delete request
5325 * Function : BuildAndSendRicSubscriptionDeleteRequest
5327 * Functionality: Build and send RIC subscription delete request.
5330 * RIC subscription info to be deleted
5331 * @return ROK - success
5334 ******************************************************************/
5335 uint8_t BuildAndSendRicSubscriptionDeleteRequest(uint32_t duId, RicSubscription *ricSubsDb)
5337 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
5338 E2AP_PDU_t *e2apMsg = NULLP;
5339 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
5340 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
5341 asn_enc_rval_t encRetVal; /* Encoder return value */
5345 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Request Message\n");
5347 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5348 if(e2apMsg == NULLP)
5350 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
5354 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5355 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5356 if(e2apMsg->choice.initiatingMessage == NULLP)
5358 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
5361 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
5362 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5363 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest;
5365 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
5368 ricSubsDelReq->protocolIEs.list.count = elementCnt;
5369 ricSubsDelReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequest_IEs_t *);
5371 RIC_ALLOC(ricSubsDelReq->protocolIEs.list.array, ricSubsDelReq->protocolIEs.list.size);
5372 if(ricSubsDelReq->protocolIEs.list.array == NULLP)
5374 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
5378 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5380 RIC_ALLOC(ricSubsDelReq->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequest_IEs_t));
5381 if(ricSubsDelReq->protocolIEs.list.array[ieIdx] == NULLP)
5383 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
5384 __func__, ieIdx, __LINE__);
5388 if(ieIdx < elementCnt)
5391 /* RIC Request ID */
5393 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
5394 ricSubsDelReqIe->id = ProtocolIE_IDE2_id_RICrequestID;
5395 ricSubsDelReqIe->criticality = CriticalityE2_reject;
5396 ricSubsDelReqIe->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RICrequestID;
5397 ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID = ricSubsDb->requestId.requestorId;
5398 ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID = ricSubsDb->requestId.instanceId;
5400 /* RAN Function ID */
5402 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
5403 ricSubsDelReqIe->id = ProtocolIE_IDE2_id_RANfunctionID;
5404 ricSubsDelReqIe->criticality = CriticalityE2_reject;
5405 ricSubsDelReqIe->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RANfunctionID;
5406 ricSubsDelReqIe->value.choice.RANfunctionID = ricSubsDb->ranFuncId;
5408 /* Prints the Msg formed */
5409 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5410 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5412 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5413 if(encRetVal.encoded == ENCODE_FAIL)
5415 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Request Message (at %s)\n",\
5416 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5421 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Request Message \n");
5422 #ifdef DEBUG_ASN_PRINT
5423 for(int i=0; i< encBufSize; i++)
5425 printf("%x",encBuf[i]);
5430 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
5432 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Request Message");
5440 FreeRicSubscriptionDeleteRequest(e2apMsg);
5444 /*******************************************************************
5446 * @brief Processing of RIC Subscription Delete Required
5450 * Function : ProcRicSubsDeleteReqd
5452 * Functionality: Processing of RIC Subscription Delete Required
5453 * When received, RIC stub will initiate the RIC subscription
5454 * deletion procedure towards DU
5457 * RIC Subscription Delete Required IEs
5458 * @return ROK-success
5461 ******************************************************************/
5462 uint8_t ProcRicSubsDeleteReqd(uint32_t duId, RICsubscriptionDeleteRequired_t *ricSubsDelRqd)
5464 uint8_t ieIdx = 0, duIdx = 0;
5465 uint16_t arrIdx = 0;
5467 RicRequestId ricReqId;
5468 RanFunction *ranFuncDb = NULLP;
5469 RicSubscription *subsDb = NULLP;
5470 CmLList *ricSubsNode = NULLP;
5472 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
5473 RICsubscription_List_withCause_t *ricSubsList = NULLP;
5474 RICsubscription_withCause_Item_t *subsItem = NULLP;
5476 memset(&ricReqId, 0, sizeof(RicRequestId));
5480 DU_LOG("\nERROR --> E2AP : %s: Received NULL message", __func__);
5484 SEARCH_DU_DB(duIdx, duId, duDb);
5487 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5491 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
5493 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
5494 switch(ricSubsDelRqdIe->id)
5496 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
5498 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
5499 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
5501 subsItem = &(((RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[arrIdx])->\
5502 value.choice.RICsubscription_withCause_Item);
5503 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, subsItem->ranFunctionID);
5506 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%ld] not found", __func__, subsItem->ranFunctionID);
5510 ricReqId.requestorId = subsItem->ricRequestID.ricRequestorID;
5511 ricReqId.instanceId = subsItem->ricRequestID.ricInstanceID;
5512 subsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
5515 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%ld] Instance_ID [%ld]", \
5516 __func__, subsItem->ricRequestID.ricRequestorID, subsItem->ricRequestID.ricInstanceID);
5520 /* Delete RIC Subcription from RAN Function */
5521 cmLListDelFrm(&ranFuncDb->subscriptionList, ricSubsNode);
5523 /* Send RIC Subscription delete request and then free any memory
5524 * allocated to store subscription info at RIC */
5525 BuildAndSendRicSubscriptionDeleteRequest(duId, (RicSubscription *)ricSubsNode->node);
5526 deleteRicSubscriptionNode(ricSubsNode);
5539 /*******************************************************************
5541 * @brief Deallocate memory allocated for E2nodeConfigurationUpdate
5545 * Function : freeE2NodeConfigItem
5548 * - freeing the memory allocated for E2nodeConfigurationUpdate
5551 * uint8_t protocolIe
5552 * PTR to e2NodeCfg which is to be freed
5553 * @return ROK - success
5556 * ****************************************************************/
5558 void freeE2NodeConfigItem(uint8_t protocolIe, PTR e2NodeCfg)
5560 E2nodeComponentConfigurationAck_t *cfgAck =NULLP;
5561 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULLP;
5562 E2nodeComponentConfigAdditionAck_Item_t *e2NodeAdditionAckItemIe=NULLP;
5563 E2nodeComponentConfigRemovalAck_Item_t *e2NodeRemovalAckItemIe=NULLP;
5564 E2nodeComponentConfigUpdateAck_Item_t *e2NodeUpdateAckItemIe=NULLP;
5566 /* Extracting the component interface and configuration ack information from
5567 * e2NodeCfg based on the protocol id */
5570 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
5572 e2NodeAdditionAckItemIe= (E2nodeComponentConfigAdditionAck_Item_t*)e2NodeCfg;
5573 switch(e2NodeAdditionAckItemIe->e2nodeComponentInterfaceType)
5575 case E2nodeComponentInterfaceType_f1:
5577 f1InterfaceInfo = e2NodeAdditionAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5586 cfgAck = &e2NodeAdditionAckItemIe->e2nodeComponentConfigurationAck;
5589 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
5591 e2NodeUpdateAckItemIe = (E2nodeComponentConfigUpdateAck_Item_t*)e2NodeCfg;
5592 switch(e2NodeUpdateAckItemIe->e2nodeComponentInterfaceType)
5594 case E2nodeComponentInterfaceType_f1:
5596 f1InterfaceInfo = e2NodeUpdateAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5604 cfgAck = &e2NodeUpdateAckItemIe->e2nodeComponentConfigurationAck;
5607 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
5609 e2NodeRemovalAckItemIe= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
5610 switch(e2NodeRemovalAckItemIe->e2nodeComponentInterfaceType)
5612 case E2nodeComponentInterfaceType_f1:
5614 f1InterfaceInfo = e2NodeRemovalAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5622 cfgAck = &e2NodeRemovalAckItemIe->e2nodeComponentConfigurationAck;
5626 /* Freeing the memory allocated to component interface and configuration ack */
5629 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
5630 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
5633 switch(cfgAck->updateOutcome)
5635 case E2nodeComponentConfigurationAck__updateOutcome_success:
5637 case E2nodeComponentConfigurationAck__updateOutcome_failure:
5639 RIC_FREE(cfgAck->failureCauseE2, sizeof(CauseE2_t));
5646 /*******************************************************************
5648 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
5652 * Function : FreeE2NodeConfigUpdate
5655 * - freeing the memory allocated for E2nodeConfigurationUpdate
5657 * @params[in] E2AP_PDU_t *e2apMsg
5658 * @return ROK - success
5661 * ****************************************************************/
5663 void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
5665 uint8_t arrIdx =0, e2NodeConfigIdx=0;
5666 E2nodeConfigurationUpdateAcknowledge_t *updateAckMsg=NULL;
5667 E2nodeComponentConfigUpdateAck_ItemIEs_t *updateAckItemIe=NULL;
5668 E2nodeComponentConfigUpdateAck_List_t *updateAckList=NULL;
5669 E2nodeComponentConfigRemovalAck_ItemIEs_t *removalAckItemIe=NULL;
5670 E2nodeComponentConfigRemovalAck_List_t *removalAckList=NULL;
5671 E2nodeComponentConfigAdditionAck_ItemIEs_t *additionAckItemIte=NULL;
5672 E2nodeComponentConfigAdditionAck_List_t *additionAckList=NULL;
5674 if(e2apMsg != NULLP)
5676 if(e2apMsg->choice.successfulOutcome != NULLP)
5678 updateAckMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
5679 if(updateAckMsg->protocolIEs.list.array != NULLP)
5681 for(arrIdx = 0; arrIdx < updateAckMsg->protocolIEs.list.count; arrIdx++)
5683 if(updateAckMsg->protocolIEs.list.array[arrIdx])
5685 switch(updateAckMsg->protocolIEs.list.array[arrIdx]->id)
5687 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
5689 additionAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
5690 if(additionAckList->list.array)
5692 for(e2NodeConfigIdx=0; e2NodeConfigIdx<additionAckList->list.count; e2NodeConfigIdx++)
5694 additionAckItemIte = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) additionAckList->list.array[e2NodeConfigIdx];
5695 if(additionAckItemIte)
5697 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck,\
5698 (PTR)&additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item);
5699 RIC_FREE(additionAckItemIte, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
5702 RIC_FREE(additionAckList->list.array, additionAckList->list.size);
5706 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
5708 updateAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
5709 if(updateAckList->list.array)
5711 for(e2NodeConfigIdx=0; e2NodeConfigIdx<updateAckList->list.count; e2NodeConfigIdx++)
5713 updateAckItemIe = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) updateAckList->list.array[e2NodeConfigIdx];
5716 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck,\
5717 (PTR)&updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item);
5718 RIC_FREE(updateAckItemIe, sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t));
5721 RIC_FREE(updateAckList->list.array, updateAckList->list.size);
5725 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
5727 removalAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
5728 if(removalAckList->list.array)
5730 for(e2NodeConfigIdx=0; e2NodeConfigIdx<removalAckList->list.count; e2NodeConfigIdx++)
5732 removalAckItemIe = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) removalAckList->list.array[e2NodeConfigIdx];
5733 if(removalAckItemIe)
5735 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck,\
5736 (PTR)&removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item);
5737 RIC_FREE(removalAckItemIe, sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t));
5740 RIC_FREE(removalAckList->list.array, removalAckList->list.size);
5745 RIC_FREE(updateAckMsg->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
5748 RIC_FREE(updateAckMsg->protocolIEs.list.array, updateAckMsg->protocolIEs.list.size);
5750 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
5752 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5756 /*******************************************************************
5758 * @brief Build E2node Component config Removal ack list
5762 * Function : BuildE2nodeComponentConfigRemovalAck
5764 * Functionality: Build the e2 node remove ack
5767 * E2nodeComponentConfigRemovalAck_List_t to be filled
5768 * Count of e2 node to be removed
5769 * list of e2 node cfg to be removed
5771 * @return ROK - success
5773 * ****************************************************************/
5775 uint8_t BuildE2nodeComponentConfigRemovalAck(E2nodeComponentConfigRemovalAck_List_t *e2NodeConfigRemovalAckList,\
5776 uint16_t removalE2NodeCount, E2NodeConfigItem *removaldE2Node)
5779 E2nodeComponentConfigRemovalAck_ItemIEs_t *e2NodeRemovalAckItem=NULL;
5781 /* Filling the e2 node config removal ack list */
5782 e2NodeConfigRemovalAckList->list.count = removalE2NodeCount;
5783 e2NodeConfigRemovalAckList->list.size = e2NodeConfigRemovalAckList->list.count * sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t*);
5784 RIC_ALLOC(e2NodeConfigRemovalAckList->list.array, e2NodeConfigRemovalAckList->list.size);
5785 if(e2NodeConfigRemovalAckList->list.array == NULLP)
5787 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
5791 for(arrIdx = 0; arrIdx< e2NodeConfigRemovalAckList->list.count; arrIdx++)
5793 RIC_ALLOC(e2NodeConfigRemovalAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t));
5794 if(e2NodeConfigRemovalAckList->list.array[arrIdx] == NULLP)
5796 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
5799 e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[arrIdx];
5800 e2NodeRemovalAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck_Item;
5801 e2NodeRemovalAckItem->criticality = CriticalityE2_reject;
5802 e2NodeRemovalAckItem->value.present = E2nodeComponentConfigRemovalAck_ItemIEs__value_PR_E2nodeComponentConfigRemovalAck_Item;
5804 /* Filling the e2 node config removal ack item */
5805 fillE2NodeConfigAck((PTR)&e2NodeRemovalAckItem->value.choice.E2nodeComponentConfigRemovalAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck,\
5806 &removaldE2Node[arrIdx].componentInfo, removaldE2Node[arrIdx].isSuccessful);
5811 /*******************************************************************
5813 * @brief Build E2node Component config update ack list
5817 * Function : BuildE2nodeComponentConfigUpdateAck
5819 * Functionality: Build E2node Component config update ack list
5822 * E2nodeComponentConfigUpdateAck_List to be filled
5823 * Count of e2 node to be update
5824 * list of e2 node cfg to be update
5826 * @return ROK - success
5828 * ****************************************************************/
5830 uint8_t BuildE2nodeComponentConfigUpdateAck(E2nodeComponentConfigUpdateAck_List_t *e2NodeConfigUpdateAckList,\
5831 uint16_t updatedE2NodeCount, E2NodeConfigItem *updatedE2Node)
5834 E2nodeComponentConfigUpdateAck_ItemIEs_t *e2NodeUpdateAckItem=NULL;
5836 /* Filling the e2 node config update ack list */
5837 e2NodeConfigUpdateAckList->list.count = updatedE2NodeCount;
5838 e2NodeConfigUpdateAckList->list.size = e2NodeConfigUpdateAckList->list.count * sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t*);
5839 RIC_ALLOC(e2NodeConfigUpdateAckList->list.array, e2NodeConfigUpdateAckList->list.size);
5840 if(e2NodeConfigUpdateAckList->list.array == NULLP)
5842 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
5846 for(arrIdx = 0; arrIdx< e2NodeConfigUpdateAckList->list.count; arrIdx++)
5848 RIC_ALLOC(e2NodeConfigUpdateAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t));
5849 if(e2NodeConfigUpdateAckList->list.array[arrIdx] == NULLP)
5851 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
5854 e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[arrIdx];
5855 e2NodeUpdateAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck_Item;
5856 e2NodeUpdateAckItem->criticality = CriticalityE2_reject;
5857 e2NodeUpdateAckItem->value.present = E2nodeComponentConfigUpdateAck_ItemIEs__value_PR_E2nodeComponentConfigUpdateAck_Item;
5859 /* Filling the e2 node config update ack item */
5860 fillE2NodeConfigAck((PTR)&e2NodeUpdateAckItem->value.choice.E2nodeComponentConfigUpdateAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck,\
5861 &updatedE2Node[arrIdx].componentInfo, updatedE2Node[arrIdx].isSuccessful);
5867 /*******************************************************************
5869 * @brief Buld and send the E2 node config update ack msg
5873 * Function : BuildAndSendE2NodeConfigUpdateAck
5876 * - Buld and send the E2 node config update ack msg
5880 * list of E2 node cfg which needs to fill in IEs
5881 * @return ROK - success
5884 * ****************************************************************/
5886 uint8_t BuildAndSendE2NodeConfigUpdateAck(DuDb *duDb, uint16_t transId, E2NodeConfigList *e2NodeList)
5888 uint8_t ret = RFAILED;
5889 uint8_t arrIdx = 0,elementCnt = 0;
5890 E2AP_PDU_t *e2apMsg = NULLP;
5891 asn_enc_rval_t encRetVal;
5892 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
5894 DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
5897 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5898 if(e2apMsg == NULLP)
5900 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5903 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
5904 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
5905 if(e2apMsg->choice.successfulOutcome == NULLP)
5907 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5911 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
5912 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
5913 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
5914 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
5917 if(e2NodeList->addedE2NodeCount)
5919 if(e2NodeList->updatedE2NodeCount)
5921 if(e2NodeList->removedE2NodeCount)
5924 e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
5925 e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
5926 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
5927 if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
5929 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5933 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
5935 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
5936 if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
5939 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5944 if(arrIdx<elementCnt)
5948 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5949 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5950 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
5951 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5953 if(e2NodeList->addedE2NodeCount)
5956 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
5957 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5958 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigAdditionAck_List;
5959 if(BuildE2nodeComponentConfigAdditionAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List,\
5960 e2NodeList->addedE2NodeCount, e2NodeList->addedE2Node)!=ROK)
5963 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
5967 if(e2NodeList->updatedE2NodeCount)
5970 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck;
5971 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5972 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigUpdateAck_List;
5973 if(BuildE2nodeComponentConfigUpdateAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List,\
5974 e2NodeList->updatedE2NodeCount, e2NodeList->updatedE2Node)!=ROK)
5977 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config update ack list");
5981 if(e2NodeList->removedE2NodeCount)
5984 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck;
5985 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5986 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigRemovalAck_List;
5987 if(BuildE2nodeComponentConfigRemovalAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List,\
5988 e2NodeList->removedE2NodeCount, e2NodeList->removedE2Node)!=ROK)
5991 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config removal ack list");
5995 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5997 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5999 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
6001 if(encRetVal.encoded == ENCODE_FAIL)
6003 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
6004 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6009 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
6010 for(int i=0; i< encBufSize; i++)
6012 DU_LOG("%x",encBuf[i]);
6018 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
6020 DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
6027 FreeE2NodeConfigUpdateAck(e2apMsg);
6032 /******************************************************************
6034 * @brief Processes the E2 removal failure msg
6038 * Function : procE2RemovalFailure
6040 * Functionality: Processes the E2 removal failure msg
6043 * E2 Removal Failure information
6047 * ****************************************************************/
6048 void ProcE2RemovalFailure(E2RemovalFailure_t *e2RemovalFailure)
6052 CauseE2_t *cause = NULLP;
6054 if(!e2RemovalFailure)
6056 DU_LOG("\nERROR --> E2AP : e2RemovalFailure pointer is null");
6060 if(!e2RemovalFailure->protocolIEs.list.array)
6062 DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
6066 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
6068 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
6070 switch(e2RemovalFailure->protocolIEs.list.array[ieIdx]->id)
6072 case ProtocolIE_IDE2_id_TransactionID:
6074 transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
6075 DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
6078 case ProtocolIE_IDE2_id_CauseE2:
6080 cause = &e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
6081 printE2ErrorCause(cause);
6086 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
6093 /*******************************************************************
6095 * @brief Delete E2 component node list
6099 * Function : deleteE2ComponentNodeList
6101 * Functionality: Delete E2 component node list
6103 * @params[in] E2 component node list
6107 ******************************************************************/
6109 void deleteE2ComponentNodeList(CmLListCp *componentList)
6111 E2NodeComponent *cfgInfo = NULLP;
6112 CmLList *e2ComponentNode = NULLP;
6114 CM_LLIST_FIRST_NODE(componentList, e2ComponentNode);
6115 while(e2ComponentNode)
6117 cfgInfo = (E2NodeComponent*)e2ComponentNode->node;
6118 cmLListDelFrm(componentList, e2ComponentNode);
6119 memset(cfgInfo, 0, sizeof(E2NodeComponent));
6120 CM_LLIST_FIRST_NODE(componentList, e2ComponentNode);
6124 /*******************************************************************
6126 * @brief process the E2 node information from ric db
6130 * Function : deleteE2NodeInfo
6132 * Functionality: process the E2 node information from ric db
6139 ******************************************************************/
6140 void deleteE2NodeInfo(DuDb *duDb)
6142 uint16_t ranFuncIdx =0;
6143 RanFunction *ranFuncDb=NULLP;
6145 DU_LOG("\nINFO --> E2AP : Removing all the E2 node information");
6146 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
6148 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
6149 if(ranFuncDb->id > 0)
6151 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
6154 deleteE2ComponentNodeList(&duDb->e2NodeComponent);
6157 /*******************************************************************
6159 * @brief process the E2 Removal Response
6163 * Function : ProcE2RemovalResponse
6165 * Functionality: Process E2 Removal Response
6169 * Pointer to removal response
6172 ******************************************************************/
6174 void ProcE2RemovalResponse(uint32_t duId, E2RemovalResponse_t *removalRsp)
6176 uint8_t ieIdx = 0, duIdx =0;
6179 SEARCH_DU_DB(duIdx, duId, duDb);
6182 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6188 DU_LOG("\nERROR --> E2AP : removalRsp pointer is null");
6192 if(!removalRsp->protocolIEs.list.array)
6194 DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
6198 for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
6200 if(removalRsp->protocolIEs.list.array[ieIdx])
6202 switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
6204 case ProtocolIE_IDE2_id_TransactionID:
6206 DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
6207 cmInetClose(&sctpCb.e2LstnSockFd);
6208 deleteE2NodeInfo(duDb);
6213 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
6220 /*******************************************************************
6222 * @brief Deallocate the memory allocated for E2 Removal Failure
6226 * Function : FreeE2RemovalFailure
6229 * - freeing the memory allocated for E2RemovalFailure
6231 * @params[in] E2AP_PDU_t *e2apMsg
6234 * ****************************************************************/
6235 void FreeE2RemovalFailure(E2AP_PDU_t *e2apMsg)
6238 E2RemovalFailure_t *e2RemovalFailure=NULLP;
6240 if(e2apMsg != NULLP)
6242 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
6244 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
6245 if(e2RemovalFailure->protocolIEs.list.array)
6247 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
6249 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
6251 RIC_FREE(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
6254 RIC_FREE(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
6256 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
6258 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6262 /*******************************************************************
6264 * @brief Buld and send the E2 Removal Failure msg
6268 * Function : BuildAndSendE2RemovalFailure
6271 * - Buld and send the E2 Removal Failure Message
6277 * @return ROK - success
6280 * ****************************************************************/
6282 uint8_t BuildAndSendRemovalFailure(uint32_t duId, uint16_t transId, CauseE2_PR causePresent, uint8_t reason)
6284 uint8_t ieIdx = 0, elementCnt = 0;
6285 uint8_t ret = RFAILED;
6286 E2AP_PDU_t *e2apMsg = NULLP;
6287 E2RemovalFailure_t *e2RemovalFailure=NULLP;
6288 asn_enc_rval_t encRetVal; /* Encoder return value */
6290 DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
6293 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6294 if(e2apMsg == NULLP)
6296 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6299 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
6301 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
6302 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
6304 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6308 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
6309 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
6310 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure;
6311 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
6314 e2RemovalFailure->protocolIEs.list.count = elementCnt;
6315 e2RemovalFailure->protocolIEs.list.size = elementCnt * sizeof(E2RemovalFailureIEs_t *);
6316 RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
6317 if(!e2RemovalFailure->protocolIEs.list.array)
6319 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6323 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6325 RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
6326 if(!e2RemovalFailure->protocolIEs.list.array[ieIdx])
6328 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6332 if(ieIdx < elementCnt)
6336 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6337 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6338 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = E2RemovalFailureIEs__value_PR_TransactionID;
6339 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
6343 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
6344 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
6345 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
6346 fillE2FailureCause(&e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
6348 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6350 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6352 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6353 if(encRetVal.encoded == ENCODE_FAIL)
6355 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
6356 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6361 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
6362 for(int i=0; i< encBufSize; i++)
6364 DU_LOG("%x",encBuf[i]);
6369 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6371 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Failure");
6379 FreeE2RemovalFailure(e2apMsg);
6383 /*******************************************************************
6385 * @brief Deallocate the memory allocated for E2 Removal Response
6389 * Function : FreeE2RemovalResponse
6392 * - freeing the memory allocated for E2RemovalResponse
6394 * @params[in] E2AP_PDU_t *e2apMsg
6395 * @return ROK - success
6398 * ****************************************************************/
6399 void FreeE2RemovalResponse(E2AP_PDU_t *e2apMsg)
6402 E2RemovalResponse_t *e2RemovalResponse=NULLP;
6404 if(e2apMsg != NULLP)
6406 if(e2apMsg->choice.successfulOutcome != NULLP)
6408 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
6409 if(e2RemovalResponse->protocolIEs.list.array)
6411 for(ieIdx=0; ieIdx < e2RemovalResponse->protocolIEs.list.count; ieIdx++)
6413 if(e2RemovalResponse->protocolIEs.list.array[ieIdx])
6415 RIC_FREE(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
6418 RIC_FREE(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
6420 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6422 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6426 /*******************************************************************
6428 * @brief Buld and send the E2 Removal Response msg
6432 * Function : BuildAndSendE2RemovalResponse
6435 * - Buld and send the E2 Removal Response Message
6439 * @return ROK - success
6442 * ****************************************************************/
6443 uint8_t BuildAndSendRemovalResponse(uint32_t duId, uint16_t transId)
6445 uint8_t ieIdx = 0, elementCnt = 0;
6446 uint8_t ret = RFAILED, duIdx =0;
6447 E2AP_PDU_t *e2apMsg = NULLP;
6449 E2RemovalResponse_t *e2RemovalResponse=NULLP;
6450 asn_enc_rval_t encRetVal; /* Encoder return value */
6452 DU_LOG("\nINFO --> E2AP : Building E2 Removal Response Message\n");
6455 SEARCH_DU_DB(duIdx, duId, duDb);
6458 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6462 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6463 if(e2apMsg == NULLP)
6465 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6468 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
6470 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6471 if(e2apMsg->choice.successfulOutcome == NULLP)
6473 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6477 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
6478 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
6479 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2RemovalResponse;
6480 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
6483 e2RemovalResponse->protocolIEs.list.count = elementCnt;
6484 e2RemovalResponse->protocolIEs.list.size = elementCnt * sizeof(E2RemovalResponseIEs_t *);
6485 RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
6486 if(!e2RemovalResponse->protocolIEs.list.array)
6488 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6492 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6494 RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
6495 if(!e2RemovalResponse->protocolIEs.list.array[ieIdx])
6497 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6501 if(ieIdx < elementCnt)
6505 e2RemovalResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6506 e2RemovalResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6507 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.present = E2RemovalResponseIEs__value_PR_TransactionID;
6508 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
6510 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6512 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6514 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6515 if(encRetVal.encoded == ENCODE_FAIL)
6517 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
6518 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6523 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
6524 for(int i=0; i< encBufSize; i++)
6526 DU_LOG("%x",encBuf[i]);
6531 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6533 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Response");
6541 FreeE2RemovalResponse(e2apMsg);
6545 /*******************************************************************
6547 * @brief Process Removal req received from RIC
6551 * Function : procE2RemovalRequest
6553 * Functionality: Process Removal req received from RIC
6557 * E2 Removal Request
6560 ******************************************************************/
6562 void procE2RemovalRequest(uint32_t duId, E2RemovalRequest_t *removalReq)
6565 uint16_t transId =0;
6567 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
6569 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
6571 switch(removalReq->protocolIEs.list.array[arrIdx]->id)
6573 case ProtocolIE_IDE2_id_TransactionID:
6575 transId = removalReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
6580 DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
6586 if(transId>=0 && transId<=255)
6588 if(BuildAndSendRemovalResponse(duId, transId) != ROK)
6590 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
6595 if(BuildAndSendRemovalFailure(duId, transId, CauseE2_PR_protocol, CauseE2Protocol_abstract_syntax_error_falsely_constructed_message) != ROK)
6597 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
6602 /*******************************************************************
6604 * @brief fill E2 connection update item
6608 * Function : fillE2connectionUpdateItem
6610 * Functionality: fill E2 connection update item
6613 * E2connectionUpdate Item to be filled
6615 * @return ROK - success
6617 * ****************************************************************/
6619 uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId)
6621 E2connectionUpdateRemove_Item_t *connectionRemoveITem=NULLP;
6622 E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
6623 TNLinformation_t *tnlInformation = NULLP;
6624 TNLusage_t *tnlUsage=NULLP;
6628 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
6630 connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
6631 tnlInformation = &connectionModifyItem->tnlInformation;
6632 tnlUsage = &connectionModifyItem->tnlUsage;
6636 case ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item:
6638 connectionRemoveITem = (E2connectionUpdateRemove_Item_t*)connectionInfo;
6639 tnlInformation= &connectionRemoveITem->tnlInformation;
6644 tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
6645 RIC_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
6646 if(!tnlInformation->tnlAddress.buf)
6648 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6652 tnlInformation->tnlAddress.buf[3] = ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr & 0xFF;
6653 tnlInformation->tnlAddress.buf[2] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 8) & 0xFF;
6654 tnlInformation->tnlAddress.buf[1] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 16) & 0xFF;
6655 tnlInformation->tnlAddress.buf[0] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 24) & 0xFF;
6656 tnlInformation->tnlAddress.bits_unused = 0;
6657 if(protocolId == ProtocolIE_IDE2_id_E2connectionUpdate_Item)
6659 *tnlUsage = TNLusage_support_function;
6664 /*******************************************************************
6666 * @brief Build E2 connection modification list
6670 * Function : BuildE2ConnectionModifyList
6672 * Functionality: Build E2 connection modification list
6675 * E2 connection modification list to be filled
6677 * @return ROK - success
6679 * ****************************************************************/
6681 uint8_t BuildE2ConnectionModifyList(E2connectionUpdate_List_t *connectionToBeModifyList)
6684 E2connectionUpdate_ItemIEs_t *connectionModify=NULL;
6686 connectionToBeModifyList->list.count = 1;
6688 connectionToBeModifyList->list.size = connectionToBeModifyList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
6689 RIC_ALLOC(connectionToBeModifyList->list.array, connectionToBeModifyList->list.size);
6690 if(connectionToBeModifyList->list.array)
6692 for(arrIdx = 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
6694 RIC_ALLOC(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
6695 if(connectionToBeModifyList->list.array[arrIdx] == NULLP)
6697 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6700 connectionModify = (E2connectionUpdate_ItemIEs_t*)connectionToBeModifyList->list.array[arrIdx];
6701 connectionModify->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
6702 connectionModify->criticality= CriticalityE2_ignore;
6703 connectionModify->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
6704 if(fillE2connectionUpdateItem((PTR)&connectionModify->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item) != ROK)
6706 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
6714 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6720 /*******************************************************************
6722 * @brief Build E2 connection remove list
6726 * Function : BuildE2ConnectionRemoveList
6728 * Functionality: Build E2 connection remove list
6731 * E2 connection remove list to be filled
6733 * @return ROK - success
6735 * ****************************************************************/
6737 uint8_t BuildE2ConnectionRemoveList(E2connectionUpdateRemove_List_t *connectionToBeRemoveList)
6740 E2connectionUpdateRemove_ItemIEs_t *connectionRemove=NULL;
6742 connectionToBeRemoveList->list.count = 1;
6744 connectionToBeRemoveList->list.size = connectionToBeRemoveList->list.count*sizeof(E2connectionUpdateRemove_ItemIEs_t*);
6745 RIC_ALLOC(connectionToBeRemoveList->list.array, connectionToBeRemoveList->list.size);
6746 if(connectionToBeRemoveList->list.array)
6748 for(arrIdx = 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
6750 RIC_ALLOC(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
6751 if(connectionToBeRemoveList->list.array[arrIdx] == NULLP)
6753 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6756 connectionRemove = (E2connectionUpdateRemove_ItemIEs_t*)connectionToBeRemoveList->list.array[arrIdx];
6757 connectionRemove->id = ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item;
6758 connectionRemove->criticality= CriticalityE2_ignore;
6759 connectionRemove->value.present = E2connectionUpdateRemove_ItemIEs__value_PR_E2connectionUpdateRemove_Item;
6760 if(fillE2connectionUpdateItem((PTR)&connectionRemove->value.choice.E2connectionUpdateRemove_Item, ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item) != ROK)
6762 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
6770 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6776 /*******************************************************************
6778 * @brief Deallocate the memory allocated for E2ConnectionUpdate msg
6782 * Function : FreeE2ConnectionUpdate
6785 * - freeing the memory allocated for E2ConnectionUpdate
6787 * @params[in] E2AP_PDU_t *e2apMsg
6788 * @return ROK - success
6791 * ****************************************************************/
6792 void FreeE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
6794 uint8_t ieIdx =0, arrIdx=0;
6795 E2connectionUpdate_t *connectionUpdate = NULLP;
6796 E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
6797 E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
6799 if(e2apMsg != NULLP)
6801 if(e2apMsg->choice.initiatingMessage != NULLP)
6803 connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
6804 if(connectionUpdate->protocolIEs.list.array)
6806 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
6808 if(connectionUpdate->protocolIEs.list.array[ieIdx])
6810 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
6812 case ProtocolIE_IDE2_id_TransactionID:
6815 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
6817 connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
6818 if(connectionToBeModifyList->list.array)
6820 for(arrIdx = 0; arrIdx < connectionToBeModifyList->list.count; arrIdx++)
6822 RIC_FREE(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
6824 RIC_FREE(connectionToBeModifyList->list.array, connectionToBeModifyList->list.size);
6829 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
6831 connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
6832 if(connectionToBeRemoveList->list.array)
6834 for(arrIdx = 0; arrIdx < connectionToBeRemoveList->list.count; arrIdx++)
6836 RIC_FREE(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
6838 RIC_FREE(connectionToBeRemoveList->list.array, connectionToBeRemoveList->list.size);
6843 RIC_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
6846 RIC_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
6848 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6850 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6854 /*******************************************************************
6856 * @brief Buld and send the E2 Connection Update msg
6860 * Function : BuildAndSendE2ConnectionUpdate
6863 * - Buld and send the E2 Connection Update Message
6866 * E2 connection to be modify or delete
6867 * @return ROK - success
6870 * ****************************************************************/
6872 uint8_t BuildAndSendE2ConnectionUpdate(uint32_t duId, E2Connection connectionInfo)
6874 uint8_t ieIdx = 0, elementCnt = 0;
6875 uint8_t ret = RFAILED, duIdx =0;
6877 E2AP_PDU_t *e2apMsg = NULLP;
6878 E2connectionUpdate_t *e2ConnectionUpdate=NULLP;
6879 asn_enc_rval_t encRetVal; /* Encoder return value */
6881 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Message\n");
6884 SEARCH_DU_DB(duIdx, duId, duDb);
6887 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6891 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6892 if(e2apMsg == NULLP)
6894 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6897 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6899 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6900 if(e2apMsg->choice.initiatingMessage == NULLP)
6902 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6906 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
6907 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6908 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2connectionUpdate;
6909 e2ConnectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
6912 if(connectionInfo == MODIFY_CONNECTION)
6914 if(connectionInfo == REMOVE_CONNECTION)
6917 e2ConnectionUpdate->protocolIEs.list.count = elementCnt;
6918 e2ConnectionUpdate->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdate_IEs_t*);
6919 RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array, e2ConnectionUpdate->protocolIEs.list.size);
6920 if(!e2ConnectionUpdate->protocolIEs.list.array)
6922 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6926 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6928 RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
6929 if(!e2ConnectionUpdate->protocolIEs.list.array[ieIdx])
6931 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6935 if(ieIdx < elementCnt)
6939 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6940 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6941 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_TransactionID;
6942 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = assignTransactionId(duDb);
6944 if(connectionInfo == MODIFY_CONNECTION)
6947 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionUpdateModify;
6948 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6949 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdate_List;
6950 if(BuildE2ConnectionModifyList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List) != ROK)
6952 DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
6957 if(connectionInfo == REMOVE_CONNECTION)
6960 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionUpdateRemove;
6961 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6962 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdateRemove_List;
6963 if(BuildE2ConnectionRemoveList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List) != ROK)
6965 DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
6970 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6972 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6974 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6975 if(encRetVal.encoded == ENCODE_FAIL)
6977 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update structure (at %s)\n",\
6978 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6983 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update \n");
6984 for(int i=0; i< encBufSize; i++)
6986 DU_LOG("%x",encBuf[i]);
6991 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6993 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update");
7001 FreeE2ConnectionUpdate(e2apMsg);
7005 /******************************************************************
7007 * @brief Processes the E2 connection update failure msg
7011 * Function : procE2connectionUpdateFailure
7013 * Functionality: Processes the E2 connection update failure msg
7016 * E2 connection update failure information
7020 * ****************************************************************/
7021 void ProcE2connectionUpdateFailure(E2connectionUpdateFailure_t *updateFailure)
7025 CauseE2_t *cause = NULLP;
7029 DU_LOG("\nERROR --> E2AP : updateFailure pointer is null");
7033 if(!updateFailure->protocolIEs.list.array)
7035 DU_LOG("\nERROR --> E2AP : updateFailure array pointer is null");
7039 for(ieIdx=0; ieIdx < updateFailure->protocolIEs.list.count; ieIdx++)
7041 if(updateFailure->protocolIEs.list.array[ieIdx])
7043 switch(updateFailure->protocolIEs.list.array[ieIdx]->id)
7045 case ProtocolIE_IDE2_id_TransactionID:
7047 transId = updateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
7048 DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
7051 case ProtocolIE_IDE2_id_CauseE2:
7053 cause = &updateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
7054 printE2ErrorCause(cause);
7059 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", updateFailure->protocolIEs.list.array[ieIdx]->id);
7067 /*******************************************************************
7069 * @brief process the E2 Connection update ack
7073 * Function : ProcE2ConnectionUpdateAck
7075 * Functionality: Process E2 Connection update ack
7079 * Pointer to Connection update ack
7082 ******************************************************************/
7084 void ProcE2ConnectionUpdateAck(uint32_t duId, E2connectionUpdateAcknowledge_t *connectionUpdateAck)
7086 uint16_t transId =0;
7087 uint32_t ipAddress=0;
7089 uint8_t ieIdx = 0, duIdx =0, arrIdx=0;
7090 E2connectionUpdate_Item_t *connectionSetupItem=NULLP;
7091 E2connectionUpdate_ItemIEs_t *connectionSetupItemIe=NULLP;
7092 E2connectionUpdate_List_t *connectionSetupList=NULLP;
7093 E2connectionSetupFailed_Item_t *setupFailedItem =NULLP;
7094 E2connectionSetupFailed_List_t *setupFailedList=NULLP;
7095 E2connectionSetupFailed_ItemIEs_t *setupFailedItemIe =NULLP;
7097 SEARCH_DU_DB(duIdx, duId, duDb);
7100 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
7104 if(!connectionUpdateAck)
7106 DU_LOG("\nERROR --> E2AP : connectionUpdateAck pointer is null");
7110 if(!connectionUpdateAck->protocolIEs.list.array)
7112 DU_LOG("\nERROR --> E2AP : connectionUpdateAck array pointer is null");
7116 for(ieIdx=0; ieIdx < connectionUpdateAck->protocolIEs.list.count; ieIdx++)
7118 if(connectionUpdateAck->protocolIEs.list.array[ieIdx])
7120 switch(connectionUpdateAck->protocolIEs.list.array[ieIdx]->id)
7122 case ProtocolIE_IDE2_id_TransactionID:
7124 transId = connectionUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
7127 DU_LOG("\nERROR --> E2AP : Received invalid trans id %d ",transId);
7132 case ProtocolIE_IDE2_id_E2connectionSetup:
7134 connectionSetupList=&connectionUpdateAck->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
7135 if(connectionSetupList->list.array)
7137 for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
7139 connectionSetupItemIe = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
7140 connectionSetupItem = &connectionSetupItemIe->value.choice.E2connectionUpdate_Item;
7141 bitStringToInt(&connectionSetupItem->tnlInformation.tnlAddress, &ipAddress);
7142 if(ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr == ipAddress)
7144 ricCb.ricCfgParams.sctpParams.usage = connectionSetupItem->tnlUsage;
7151 case ProtocolIE_IDE2_id_E2connectionSetupFailed:
7153 setupFailedList=&connectionUpdateAck->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
7154 if(setupFailedList->list.array)
7156 for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
7158 setupFailedItemIe = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
7159 setupFailedItem = &setupFailedItemIe->value.choice.E2connectionSetupFailed_Item;
7160 printE2ErrorCause(&setupFailedItem->cause);
7167 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", connectionUpdateAck->protocolIEs.list.array[ieIdx]->id);
7175 /******************************************************************
7177 * @brief Processes the Ric Subs delete failure msg
7181 * Function : procRicSubsDeleteFailure
7183 * Functionality: Processes the Ric Subs delete failure msg
7186 * Ric Subs delete failure information
7190 * ****************************************************************/
7191 void ProcRicSubsDeleteFailure(RICsubscriptionDeleteFailure_t *ricSubsDeleteFail)
7194 uint16_t ranFuncId=0;
7195 CauseE2_t *cause = NULLP;
7196 RICrequestID_t ricRequestID;
7198 if(!ricSubsDeleteFail)
7200 DU_LOG("\nERROR --> E2AP : ricSubsDeleteFail pointer is null");
7204 if(!ricSubsDeleteFail->protocolIEs.list.array)
7206 DU_LOG("\nERROR --> E2AP : ricSubsDeleteFail array pointer is null");
7210 for(ieIdx=0; ieIdx < ricSubsDeleteFail->protocolIEs.list.count; ieIdx++)
7212 if(ricSubsDeleteFail->protocolIEs.list.array[ieIdx])
7214 switch(ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->id)
7216 case ProtocolIE_IDE2_id_RICrequestID:
7218 memcpy(&ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t));
7219 DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
7222 case ProtocolIE_IDE2_id_RANfunctionID:
7224 ranFuncId = ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
7225 DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId);
7228 case ProtocolIE_IDE2_id_CauseE2:
7230 cause = &ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
7231 printE2ErrorCause(cause);
7236 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->id);
7245 /******************************************************************
7247 * @brief Processes the Ric Subs delete rsp msg
7251 * Function : ProcRicSubsDeleteRsp
7253 * Functionality: Processes the Ric Subs delete rsp msg
7256 * Ric Subs delete rsp information
7260 * ****************************************************************/
7261 void ProcRicSubsDeleteRsp(uint32_t duId, RICsubscriptionDeleteResponse_t *ricSubsDeleteRsp)
7265 uint16_t ranFuncId=0;
7266 RanFunction *ranFuncDb = NULLP;
7267 RicRequestId ricReqId;
7269 RicSubscription *ricSubs = NULLP;
7270 CmLList *ricSubsNode = NULLP;
7272 SEARCH_DU_DB(duIdx, duId, duDb);
7275 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
7279 if(!ricSubsDeleteRsp)
7281 DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp pointer is null");
7285 if(!ricSubsDeleteRsp->protocolIEs.list.array)
7287 DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp array pointer is null");
7290 for(ieIdx=0; ieIdx < ricSubsDeleteRsp->protocolIEs.list.count; ieIdx++)
7292 if(ricSubsDeleteRsp->protocolIEs.list.array[ieIdx])
7294 switch(ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->id)
7296 case ProtocolIE_IDE2_id_RICrequestID:
7298 ricReqId.requestorId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricRequestorID;
7299 ricReqId.instanceId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricInstanceID;
7302 case ProtocolIE_IDE2_id_RANfunctionID:
7304 ranFuncId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
7305 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
7308 DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
7312 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
7315 deleteRicSubscriptionNode(ricSubsNode);
7316 DU_LOG("\nINFO --> E2AP : Ric subscription node deleted successfully");
7320 DU_LOG("\nERROR --> E2AP : Ric subscription node is not present ");
7331 /******************************************************************
7333 * @brief Processes the Ric Subs modification failure msg
7337 * Function : procRicSubsModificationFailure
7339 * Functionality: Processes the Ric Subs modification failure msg
7342 * Ric Subs modification failure information
7346 * ****************************************************************/
7347 void ProcRicSubsModificationFailure(RICsubscriptionModificationFailure_t *ricSubsModificationFail)
7350 uint16_t ranFuncId=0;
7351 CauseE2_t *cause = NULLP;
7352 RICrequestID_t ricRequestID;
7354 DU_LOG("\nINFO --> E2AP : Ric subscription modification failure received");
7356 if(!ricSubsModificationFail)
7358 DU_LOG("\nERROR --> E2AP : ricSubsModificationFail pointer is null");
7362 if(!ricSubsModificationFail->protocolIEs.list.array)
7364 DU_LOG("\nERROR --> E2AP : ricSubsModificationFail array pointer is null");
7368 for(ieIdx=0; ieIdx < ricSubsModificationFail->protocolIEs.list.count; ieIdx++)
7370 if(ricSubsModificationFail->protocolIEs.list.array[ieIdx])
7372 switch(ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id)
7374 case ProtocolIE_IDE2_id_RICrequestID:
7376 memcpy(&ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t));
7377 DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
7380 case ProtocolIE_IDE2_id_RANfunctionID:
7382 ranFuncId = ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
7383 DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId);
7386 case ProtocolIE_IDE2_id_CauseE2:
7388 cause = &ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
7389 printE2ErrorCause(cause);
7394 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id);
7402 /*******************************************************************
7404 * @brief Free RIC Subscription action to be added list
7408 * Function : FreeRicSubsActionToBeAdded
7410 * Functionality: Free the RIC Subscription action to be added list
7412 * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
7415 * ****************************************************************/
7416 void FreeRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
7418 uint8_t elementIdx = 0;
7419 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
7421 if(subsDetails->list.array)
7423 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
7425 if(subsDetails->list.array[elementIdx])
7427 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
7428 RIC_FREE(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf, \
7429 addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.size);
7430 RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t));
7433 RIC_FREE(subsDetails->list.array, subsDetails->list.size);
7437 /*******************************************************************
7439 * @brief Free RIC Subscription action to be removed list
7443 * Function : FreeRicSubsActionToBeRemoved
7445 * Functionality: Free the RIC Subscription action to be removed list
7447 * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
7450 * ****************************************************************/
7451 void FreeRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
7453 uint8_t elementIdx = 0;
7455 if(subsDetails->list.array)
7457 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
7459 RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t));
7461 RIC_FREE(subsDetails->list.array, subsDetails->list.size);
7465 /*******************************************************************
7467 * @brief Free RIC Subscription action to be modify
7471 * Function : FreeRicSubsActionToBeModified
7473 * Functionality: Free the RIC Subscription action to be modify
7475 * @params[in] RICactions_ToBeModifiedForModification_List_t List
7478 * ****************************************************************/
7479 void FreeRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
7481 uint8_t elementIdx = 0;
7482 RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
7484 if(subsDetails->list.array)
7486 for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
7488 if(subsDetails->list.array[elementIdx])
7490 actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx];
7491 if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
7493 RIC_FREE(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf, \
7494 actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->size);
7495 RIC_FREE(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
7497 RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t))
7500 RIC_FREE(subsDetails->list.array, subsDetails->list.size);
7504 /*******************************************************************
7506 * @brief Free RIC Subscription modification Request
7510 * Function :FreeRicSubscriptionModReq
7512 * Functionality : Free RIC Subscription modification Request
7514 * @params[in] E2AP_PDU
7517 ******************************************************************/
7518 void FreeRicSubscriptionModReq(E2AP_PDU_t *e2apRicMsg)
7521 RICsubscriptionModificationRequest_t *ricSubscriptionModReq =NULLP;
7522 RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe=NULLP;
7526 if(e2apRicMsg->choice.initiatingMessage)
7528 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
7529 if(ricSubscriptionModReq->protocolIEs.list.array)
7531 for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
7533 if(ricSubscriptionModReq->protocolIEs.list.array[idx])
7535 ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
7536 switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
7538 case ProtocolIE_IDE2_id_RICrequestID:
7540 case ProtocolIE_IDE2_id_RANfunctionID:
7542 case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
7544 FreeRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
7547 case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
7549 FreeRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
7552 case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
7554 FreeRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
7559 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
7565 RIC_FREE(ricSubscriptionModReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionModificationRequest_IEs_t));
7568 RIC_FREE(ricSubscriptionModReq->protocolIEs.list.array, ricSubscriptionModReq->protocolIEs.list.size);
7570 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7572 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
7576 /*******************************************************************
7578 * @brief Build Ric subscription action to be modify list
7582 * Function : BuildRicSubsActionToBeModify
7584 * Functionality: Build Ric subscription action to be modify list
7587 * RICactions_ToBeModifiedForModification_List_t to be filled
7588 * Num of action to be modify
7589 * List of action to be modify
7591 * @return ROK - success
7594 ******************************************************************/
7596 uint8_t BuildRicSubsActionToBeModify(RICactions_ToBeModifiedForModification_List_t *modifyActionList, uint8_t numOfActionToBeModify, ActionInfo *actionToBeModify)
7599 RICaction_ToBeModifiedForModification_ItemIEs_t *modifiedActionItemIe=NULLP;
7601 modifyActionList->list.count = numOfActionToBeModify;
7602 modifyActionList->list.size = modifyActionList->list.count * sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t*);
7603 RIC_ALLOC(modifyActionList->list.array, modifyActionList->list.size);
7604 if(!modifyActionList->list.array)
7606 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7610 for(arrIdx = 0; arrIdx< modifyActionList->list.count; arrIdx++)
7612 RIC_ALLOC(modifyActionList->list.array[arrIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t));
7613 if(!modifyActionList->list.array[arrIdx])
7615 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7618 modifiedActionItemIe = (RICaction_ToBeModifiedForModification_ItemIEs_t*)modifyActionList->list.array[arrIdx];
7619 modifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item;
7620 modifiedActionItemIe->criticality = CriticalityE2_ignore;
7621 modifiedActionItemIe->value.present = RICaction_ToBeModifiedForModification_ItemIEs__value_PR_RICaction_ToBeModifiedForModification_Item;
7622 modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID = actionToBeModify[arrIdx].actionId;
7624 /* RIC Action Definition */
7625 RIC_ALLOC(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
7626 if(!modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
7628 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7632 if(fillRicActionDef(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition,\
7633 actionToBeModify[arrIdx].actionId, CONFIG_MOD) != ROK)
7635 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7643 /*******************************************************************
7645 * @brief Build Ric subscription action to be removed list
7649 * Function : BuildRicSubsActionToBeRemoved
7651 * Functionality: Build Ric subscription action to be removed list
7654 * RICactions_ToBeRemovedForModification_List_t to be filled
7655 * Num Of Action To Be Remove
7656 * Action remove list
7658 * @return ROK - success
7661 ******************************************************************/
7663 uint8_t BuildRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *removeActionList, uint8_t numOfActionToBeRemove, ActionInfo *actionToBeRemove)
7666 RICaction_ToBeRemovedForModification_ItemIEs_t *removeActionItemIe=NULLP;
7668 removeActionList->list.count = numOfActionToBeRemove;
7669 removeActionList->list.size = removeActionList->list.count * sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t*);
7670 RIC_ALLOC(removeActionList->list.array, removeActionList->list.size);
7671 if(!removeActionList->list.array)
7673 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7677 for(arrIdx = 0; arrIdx< removeActionList->list.count; arrIdx++)
7679 RIC_ALLOC(removeActionList->list.array[arrIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t));
7680 if(!removeActionList->list.array[arrIdx])
7682 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7685 removeActionItemIe = (RICaction_ToBeRemovedForModification_ItemIEs_t*)removeActionList->list.array[arrIdx];
7686 removeActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item;
7687 removeActionItemIe->criticality = CriticalityE2_ignore;
7688 removeActionItemIe->value.present = RICaction_ToBeRemovedForModification_ItemIEs__value_PR_RICaction_ToBeRemovedForModification_Item;
7689 removeActionItemIe->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID = actionToBeRemove[arrIdx].actionId;
7694 /*******************************************************************
7696 * @brief Build Ric subscription action to be added list
7700 * Function : BuildRicSubsActionToBeAdded
7702 * Functionality: Build Ric subscription action to be added list
7705 * RICactions_ToBeAddedForModification_List_t to be filled
7706 * Num Of Action To Be added
7709 * @return ROK - success
7712 ******************************************************************/
7714 uint8_t BuildRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *addedActionList, RicSubscription **ricSubsInfo, uint8_t numOfActionToBeAdded, ActionInfo *actionToBeAdded)
7717 CmLList *actionNode=NULLP;
7718 RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe;
7720 addedActionList->list.count = numOfActionToBeAdded;
7721 addedActionList->list.size = addedActionList->list.count * sizeof(RICaction_ToBeAddedForModification_ItemIEs_t*);
7722 RIC_ALLOC(addedActionList->list.array, addedActionList->list.size);
7723 if(!addedActionList->list.array)
7725 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7729 for(arrIdx = 0; arrIdx< addedActionList->list.count; arrIdx++)
7731 RIC_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t));
7732 if(!addedActionList->list.array[arrIdx])
7734 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7737 addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx];
7738 addedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item;
7739 addedActionItemIe->criticality = CriticalityE2_ignore;
7740 addedActionItemIe->value.present = RICaction_ToBeAddedForModification_ItemIEs__value_PR_RICaction_ToBeAddedForModification_Item;
7741 addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionID = actionToBeAdded[arrIdx].actionId;
7743 addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionType = RICactionType_report;
7745 if(fillRicActionDef(&addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition, \
7746 actionToBeAdded[arrIdx].actionId, CONFIG_ADD) != ROK)
7748 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7752 actionNode = addRicSubsAction((*ricSubsInfo)->actionSequence.count, &(*ricSubsInfo)->actionSequence);
7753 if(actionNode == NULLP)
7755 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7762 /*******************************************************************
7764 * @brief Builds and Send the RicSubscriptionModReq
7768 * Function : BuildAndSendRicSubscriptionModReq
7770 * Functionality:Builds and Send the RicSubscriptionModReq
7774 * Ric subs information
7775 * List of ric subs action which needs to modify/add/remove
7776 * @return ROK - success
7779 ******************************************************************/
7781 uint8_t BuildAndSendRicSubscriptionModReq(DuDb *duDb, RicSubscription **ricSubsInfo, RicSubsModReq ricSubsModReq)
7783 uint8_t ret = RFAILED;
7784 uint8_t elementCnt = 0;
7786 asn_enc_rval_t encRetVal; /* Encoder return value */
7787 E2AP_PDU_t *e2apRicMsg = NULL;
7788 RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
7790 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
7794 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
7795 if(e2apRicMsg == NULLP)
7797 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7801 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
7802 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
7803 if(e2apRicMsg->choice.initiatingMessage == NULLP)
7805 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7808 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
7809 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
7810 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest;
7812 ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
7814 /* Increasing the elment count based on the number of configured action to be add, mod, delete */
7816 if(ricSubsModReq.numOfActionToBeAdded)
7818 if(ricSubsModReq.numOfActionToBeModify)
7820 if(ricSubsModReq.numOfActionToBeRemove)
7823 ricSubscriptionModReq->protocolIEs.list.count = elementCnt;
7824 ricSubscriptionModReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequest_IEs_t);
7826 /* Initialize the subscription members */
7827 RIC_ALLOC(ricSubscriptionModReq->protocolIEs.list.array, ricSubscriptionModReq->protocolIEs.list.size);
7828 if(ricSubscriptionModReq->protocolIEs.list.array == NULLP)
7830 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7834 for(idx=0; idx<elementCnt; idx++)
7836 RIC_ALLOC(ricSubscriptionModReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionModificationRequest_IEs_t));
7837 if(ricSubscriptionModReq->protocolIEs.list.array[idx] == NULLP)
7839 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
7843 if(idx < elementCnt)
7846 /* Filling RIC Request Id */
7848 ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
7849 ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
7850 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present =\
7851 RICsubscriptionModificationRequest_IEs__value_PR_RICrequestID;
7852 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = (*ricSubsInfo)->requestId.requestorId;
7853 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = (*ricSubsInfo)->requestId.instanceId;
7855 /* Filling RAN Function Id */
7857 ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
7858 ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
7859 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present =\
7860 RICsubscriptionModificationRequest_IEs__value_PR_RANfunctionID;
7861 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = (*ricSubsInfo)->ranFuncId;
7863 if(ricSubsModReq.numOfActionToBeRemove)
7865 /* Filling RIC Subscription action to be removed */
7867 ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List;
7868 ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore;
7869 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeRemovedForModification_List;
7870 if(BuildRicSubsActionToBeRemoved(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeRemovedForModification_List,\
7871 ricSubsModReq.numOfActionToBeRemove, ricSubsModReq.actionToBeRemove) != ROK)
7873 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7877 if(ricSubsModReq.numOfActionToBeModify)
7879 /* Filling RIC Subscription action to be modified */
7881 ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List;
7882 ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore;
7883 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeModifiedForModification_List;
7884 if(BuildRicSubsActionToBeModify(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeModifiedForModification_List,\
7885 ricSubsModReq.numOfActionToBeModify, ricSubsModReq.actionToBeModify) != ROK)
7887 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7892 if(ricSubsModReq.numOfActionToBeAdded)
7894 /* Filling RIC Subscription action to be added */
7896 ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List;
7897 ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore;
7898 ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeAddedForModification_List;
7899 if(BuildRicSubsActionToBeAdded(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeAddedForModification_List,\
7900 ricSubsInfo, ricSubsModReq.numOfActionToBeAdded, ricSubsModReq.actionToBeAdded) != ROK)
7902 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
7907 /* Prints the Msg formed */
7908 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
7910 memset(encBuf, 0, ENC_BUF_MAX_LEN);
7912 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
7913 if(encRetVal.encoded == ENCODE_FAIL)
7915 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionModRequest structure (at %s)\n",\
7916 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7921 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionModRequest\n");
7922 for(int i=0; i< encBufSize; i++)
7924 DU_LOG("%x",encBuf[i]);
7929 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
7931 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
7939 FreeRicSubscriptionModReq(e2apRicMsg);
7943 /*******************************************************************
7945 * @brief Builds RicSubscriptionModReq
7949 * Function : BuildRicSubscriptionModReq
7951 * Functionality:Builds the RicSubscriptionModReq
7957 * ****************************************************************/
7959 void BuildRicSubsModificationReq(DuDb *duDb, RicSubscription *ricSubsInfo)
7961 CmLList *actionNode=NULLP;
7962 uint8_t actionToBeAdded =0;
7963 uint8_t actionIdx =0, tmpActionIdx=0;
7964 ActionInfo *actionInfoDb = NULLP;
7965 RicSubsModReq ricSubsModReq;
7969 memset(&ricSubsModReq, 0, sizeof(RicSubsModReq));
7972 CM_LLIST_FIRST_NODE(&ricSubsInfo->actionSequence, actionNode);
7975 actionInfoDb = (ActionInfo*)(actionNode->node);
7976 /* Change the condition based on the action required to be modiified or removed */
7977 if(((actionInfoDb->actionId+1)%2) == 0)
7979 tmpActionIdx = ricSubsModReq.numOfActionToBeModify;
7980 ricSubsModReq.actionToBeModify[tmpActionIdx].actionId = actionInfoDb->actionId;
7981 ricSubsModReq.numOfActionToBeModify++;
7985 tmpActionIdx = ricSubsModReq.numOfActionToBeRemove;
7986 ricSubsModReq.actionToBeRemove[tmpActionIdx].actionId = actionInfoDb->actionId;
7987 ricSubsModReq.numOfActionToBeRemove++;
7989 actionNode= actionNode->next;
7991 /* Change the value of actionToBeAdded based on the number of action required to be added */
7993 tmpActionIdx = ricSubsInfo->actionSequence.count;
7994 for(actionIdx=0; actionIdx<actionToBeAdded; actionIdx++)
7996 ricSubsModReq.actionToBeAdded[actionIdx].actionId = tmpActionIdx;
7997 ricSubsModReq.numOfActionToBeAdded++;
8001 if(BuildAndSendRicSubscriptionModReq(duDb, &ricSubsInfo, ricSubsModReq) != ROK)
8003 DU_LOG("\nERROR --> E2AP : failed to build and send RIC Subscription Modification");
8009 /****************************************************************
8011 * @brief Processing RIC Subscription action modified list
8015 * Function :ProcessingRicSubsActionModified
8017 * Functionality: Processing the RIC Subscription action modified list
8019 * @params[in] RICactions_AddedForModification_List_t
8022 * ****************************************************************/
8023 void ProcessingRicSubsActionModified(RICactions_ModifiedForModification_List_t *actionModifiedList)
8026 uint8_t elementIdx = 0;
8027 RICaction_ModifiedForModification_ItemIEs_t *modifiedActionItemIe =NULLP;
8029 if(actionModifiedList->list.array)
8031 for(elementIdx = 0; elementIdx < actionModifiedList->list.count; elementIdx++)
8033 if(actionModifiedList->list.array[elementIdx])
8035 modifiedActionItemIe=(RICaction_ModifiedForModification_ItemIEs_t*)actionModifiedList->list.array[elementIdx];
8036 actionId = modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID;
8037 DU_LOG("\nInfo --> E2AP : Action id %d modified successfully", actionId);
8045 /****************************************************************
8047 * @brief Processing RIC Subscription action added list
8051 * Function : ProcessingRicSubsActionAdded
8053 * Functionality: Processing RIC Subscription action added list
8055 * @params[in] RICactions_AddedForModification_List_t
8058 * ****************************************************************/
8059 void ProcessingRicSubsActionAdded(RICactions_AddedForModification_List_t *actionAddedList)
8062 uint8_t elementIdx = 0;
8063 RICaction_AddedForModification_ItemIEs_t *addedActionItemIe =NULLP;
8065 if(actionAddedList->list.array)
8067 for(elementIdx = 0; elementIdx < actionAddedList->list.count; elementIdx++)
8069 if(actionAddedList->list.array[elementIdx])
8071 addedActionItemIe=(RICaction_AddedForModification_ItemIEs_t*)actionAddedList->list.array[elementIdx];
8072 actionId = addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID;
8073 DU_LOG("\nInfo --> E2AP : Action id %d added successfully", actionId);
8081 /****************************************************************
8083 * @brief Processing RIC Subscription action deleted list
8087 * Function : ProcessingRicSubsActionRemoved
8089 * Functionality: Processing RIC Subscription action deleted list
8091 * @params[in] RICactions_RemovedForModification_List_t
8092 * Ric Subscription info
8095 * ****************************************************************/
8096 void ProcessingRicSubsActionRemoved(RICactions_RemovedForModification_List_t *actionRemovedList, RicSubscription *ricSubs)
8099 uint8_t elementIdx = 0;
8100 ActionInfo *action=NULLP;
8101 CmLList *actionNode =NULLP;
8102 RICaction_RemovedForModification_ItemIEs_t *removedActionItemIe =NULLP;
8104 if(actionRemovedList->list.array)
8106 for(elementIdx = 0; elementIdx < actionRemovedList->list.count; elementIdx++)
8108 if(actionRemovedList->list.array[elementIdx])
8110 removedActionItemIe=(RICaction_RemovedForModification_ItemIEs_t*)actionRemovedList->list.array[elementIdx];
8111 actionId = removedActionItemIe->value.choice.RICaction_RemovedForModification_Item.ricActionID;
8112 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
8115 cmLListDelFrm(&ricSubs->actionSequence, actionNode);
8116 deleteActionSequence(actionNode);
8117 DU_LOG("\nInfo --> E2AP : Action id %d removed successfully", actionId);
8126 /*******************************************************************
8128 * @brief Processing RIC Subscription action failed to be
8133 * Function : ProcessingRicSubsActionFailedToBeRemoved
8135 * Functionality: Processing the RIC Subscription action failed
8136 * to be removed list
8138 * @params[in] RICactions_FailedToBeRemovedForModification_List_t
8141 * ****************************************************************/
8142 void ProcessingRicSubsActionFailedToBeRemoved(RICactions_FailedToBeRemovedForModification_List_t *actionFailedToBeRemoved)
8145 uint8_t elementIdx = 0;
8146 RICaction_FailedToBeRemovedForModification_ItemIEs_t *failedToBeRemovedActionItemIe =NULLP;
8148 if(actionFailedToBeRemoved->list.array)
8150 for(elementIdx = 0; elementIdx < actionFailedToBeRemoved->list.count; elementIdx++)
8152 if(actionFailedToBeRemoved->list.array[elementIdx])
8154 failedToBeRemovedActionItemIe=(RICaction_FailedToBeRemovedForModification_ItemIEs_t*)actionFailedToBeRemoved->list.array[elementIdx];
8155 actionId = failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID;
8156 DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId, __func__);
8157 printE2ErrorCause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause);
8165 /****************************************************************
8167 * @brief Processing RIC Subscription action failed to be
8172 * Function : ProcessingRicSubsActionFailedToBeAdded
8174 * Functionality: Processing the RIC Subscription action failed
8177 * @params[in] RICactions_FailedToBeAddedForModification_List_t
8180 * ****************************************************************/
8181 void ProcessingRicSubsActionFailedToBeAdded(RICactions_FailedToBeAddedForModification_List_t *actionfailedToBeAddedList, RicSubscription *ricSubs)
8184 uint8_t elementIdx = 0;
8185 ActionInfo *action=NULLP;
8186 CmLList *actionNode =NULLP;
8187 RICaction_FailedToBeAddedForModification_ItemIEs_t *failedToBeAddedActionItemIe =NULLP;
8189 if(actionfailedToBeAddedList->list.array)
8191 for(elementIdx = 0; elementIdx < actionfailedToBeAddedList->list.count; elementIdx++)
8193 if(actionfailedToBeAddedList->list.array[elementIdx])
8195 failedToBeAddedActionItemIe=(RICaction_FailedToBeAddedForModification_ItemIEs_t*)actionfailedToBeAddedList->list.array[elementIdx];
8196 actionId = failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.ricActionID;
8197 action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
8200 cmLListDelFrm(&ricSubs->actionSequence, actionNode);
8201 deleteActionSequence(actionNode);
8203 DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__);
8204 printE2ErrorCause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause);
8212 /*******************************************************************
8214 * @brief Processing RIC Subscription action failed to be
8219 * Function :ProcessingRicSubsActionFailedToBeModified
8221 * Functionality: Processing the RIC Subscription action failed
8222 * to be modified list
8224 * @params[in] RICactions_FailedToBeModifiedForModification_List_t
8227 * ****************************************************************/
8228 void ProcessingRicSubsActionFailedToBeModified(RICactions_FailedToBeModifiedForModification_List_t *actionFailedToBeModifiedList)
8231 uint8_t elementIdx = 0;
8232 RICaction_FailedToBeModifiedForModification_ItemIEs_t *failedToBeModifiedActionItemIe =NULLP;
8234 if(actionFailedToBeModifiedList->list.array)
8236 for(elementIdx = 0; elementIdx < actionFailedToBeModifiedList->list.count; elementIdx++)
8238 if(actionFailedToBeModifiedList->list.array[elementIdx])
8240 failedToBeModifiedActionItemIe=(RICaction_FailedToBeModifiedForModification_ItemIEs_t*)actionFailedToBeModifiedList->list.array[elementIdx];
8241 actionId = failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID;
8242 DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__);
8243 printE2ErrorCause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause);
8251 /******************************************************************
8253 * @brief Processes the Ric Subs modification rsp msg
8257 * Function : ProcRicSubsModificationRsp
8259 * Functionality: Processes the Ric Subs modification rsp msg
8262 * Ric Subs modification rsp information
8266 * ****************************************************************/
8267 void ProcRicSubsModificationRsp(uint32_t duId, RICsubscriptionModificationResponse_t *ricSubsModificationRsp)
8271 uint16_t ranFuncId=0;
8272 RanFunction *ranFuncDb = NULLP;
8273 RicRequestId ricReqId;
8275 RicSubscription *ricSubs = NULLP;
8276 CmLList *ricSubsNode = NULLP;
8278 SEARCH_DU_DB(duIdx, duId, duDb);
8281 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
8285 if(!ricSubsModificationRsp)
8287 DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp pointer is null");
8291 if(!ricSubsModificationRsp->protocolIEs.list.array)
8293 DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp array pointer is null");
8297 for(ieIdx=0; ieIdx < ricSubsModificationRsp->protocolIEs.list.count; ieIdx++)
8299 if(ricSubsModificationRsp->protocolIEs.list.array[ieIdx])
8301 switch(ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id)
8303 case ProtocolIE_IDE2_id_RICrequestID:
8305 ricReqId.requestorId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricRequestorID;
8306 ricReqId.instanceId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricInstanceID;
8309 case ProtocolIE_IDE2_id_RANfunctionID:
8311 ranFuncId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
8312 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
8315 DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
8319 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
8322 DU_LOG("\nERROR --> E2AP : Ric subscription node is not present ");
8327 case ProtocolIE_IDE2_id_RICactionsRemovedForModification_List:
8329 ProcessingRicSubsActionRemoved(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_RemovedForModification_List, ricSubs);
8332 case ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List:
8334 ProcessingRicSubsActionFailedToBeRemoved(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeRemovedForModification_List);
8337 case ProtocolIE_IDE2_id_RICactionsModifiedForModification_List:
8339 ProcessingRicSubsActionModified(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_ModifiedForModification_List);
8342 case ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List:
8344 ProcessingRicSubsActionFailedToBeModified(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeModifiedForModification_List);
8347 case ProtocolIE_IDE2_id_RICactionsAddedForModification_List:
8349 ProcessingRicSubsActionAdded(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_AddedForModification_List);
8352 case ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List:
8354 ProcessingRicSubsActionFailedToBeAdded(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeAddedForModification_List, ricSubs);
8359 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id);
8367 /*******************************************************************
8369 * @brief Handles received E2AP message and sends back response
8373 * Function : E2APMsgHdlr
8376 * - Decodes received E2AP control message
8377 * - Prepares response message, encodes and sends to SCTP
8380 * @return ROK - success
8383 * ****************************************************************/
8384 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
8390 E2AP_PDU_t *e2apMsg;
8391 asn_dec_rval_t rval; /* Decoder return value */
8392 E2AP_PDU_t e2apasnmsg ;
8394 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
8395 ODU_PRINT_MSG(mBuf, 0,0);
8397 /* Copy mBuf into char array to decode it */
8398 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
8399 RIC_ALLOC(recvBuf, (Size)recvBufLen);
8401 if(recvBuf == NULLP)
8403 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
8406 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
8408 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
8412 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
8413 for(i=0; i< recvBufLen; i++)
8415 DU_LOG("%x",recvBuf[i]);
8418 /* Decoding flat buffer into E2AP messsage */
8419 e2apMsg = &e2apasnmsg;
8420 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
8422 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
8423 RIC_FREE(recvBuf, (Size)recvBufLen);
8425 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
8427 DU_LOG("\nERROR --> E2AP : ASN decode failed");
8431 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
8433 switch(e2apMsg->present)
8435 case E2AP_PDU_PR_initiatingMessage:
8437 switch(e2apMsg->choice.initiatingMessage->value.present)
8439 case InitiatingMessageE2__value_PR_E2setupRequest:
8441 DU_LOG("\nINFO --> E2AP : E2 setup request received");
8442 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
8445 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
8447 DU_LOG("\nINFO --> E2AP : E2 node config update received");
8448 ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate);
8451 case InitiatingMessageE2__value_PR_ResetRequestE2:
8453 DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
8454 ProcResetRequest(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
8457 case InitiatingMessageE2__value_PR_RICindication:
8459 DU_LOG("\nINFO --> E2AP : RIC Indication received");
8462 case InitiatingMessageE2__value_PR_RICserviceUpdate:
8464 DU_LOG("\nINFO --> E2AP : RIC Service update received");
8465 ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate);
8468 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired:
8470 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Required");
8471 ProcRicSubsModReqd(*duId, \
8472 &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired);
8475 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired:
8477 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Required");
8478 ProcRicSubsDeleteReqd(*duId, \
8479 &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired);
8483 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
8485 DU_LOG("\nINFO --> E2AP : Error indication received");
8488 case InitiatingMessageE2__value_PR_E2RemovalRequest:
8490 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
8491 procE2RemovalRequest(*duId,\
8492 &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest);
8497 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \
8498 e2apMsg->choice.initiatingMessage->value.present);
8501 }/* End of switch(initiatingMessage) */
8504 case E2AP_PDU_PR_successfulOutcome:
8506 switch(e2apMsg->choice.successfulOutcome->value.present)
8508 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
8510 DU_LOG("\nINFO --> E2AP : Reset response received");
8511 ProcResetResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2);
8514 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
8516 ProcRicSubscriptionResponse(*duId, \
8517 &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse);
8520 case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
8522 ProcE2RemovalResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse);
8525 case SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge:
8527 ProcE2ConnectionUpdateAck(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge);
8530 case SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse:
8532 ProcRicSubsDeleteRsp(*duId, &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse);
8535 case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationResponse:
8537 ProcRicSubsModificationRsp(*duId, &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse);
8542 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \
8543 e2apMsg->choice.successfulOutcome->value.present);
8550 case E2AP_PDU_PR_unsuccessfulOutcome:
8552 switch(e2apMsg->choice.successfulOutcome->value.present)
8554 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure:
8556 ProcRicSubscriptionFailure(*duId, \
8557 &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure);
8560 case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
8562 ProcE2RemovalFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure);
8565 case UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure:
8567 ProcE2connectionUpdateFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure);
8570 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteFailure:
8572 ProcRicSubsDeleteFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure);
8575 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure:
8577 ProcRicSubsModificationFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure);
8582 DU_LOG("\nERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \
8583 e2apMsg->choice.unsuccessfulOutcome->value.present);
8591 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
8595 }/* End of switch(e2apMsg->present) */
8596 } /* End of E2APMsgHdlr */
8599 /**********************************************************************
8601 **********************************************************************/