1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
19 /* This file contains E2AP message handler functions */
20 #include "common_def.h"
21 #include "OCTET_STRING.h"
22 #include "BIT_STRING.h"
23 #include "odu_common_codec.h"
24 #include "ric_stub_sctp.h"
26 #include "ric_e2ap_msg_hdl.h"
27 #include "GlobalE2node-gNB-ID.h"
28 #include "ProtocolIE-FieldE2.h"
29 #include "InitiatingMessageE2.h"
30 #include "SuccessfulOutcomeE2.h"
31 #include "UnsuccessfulOutcomeE2.h"
34 #include "E2nodeComponentInterfaceF1.h"
35 #include "E2SM-KPM-RANfunction-Description.h"
36 #include "RANfunction-Name.h"
37 #include "RIC-EventTriggerStyle-Item.h"
38 #include "RIC-ReportStyle-Item.h"
39 #include "MeasurementInfo-Action-Item.h"
40 #include "MeasurementInfoItem.h"
41 #include "E2SM-KPM-ActionDefinition-Format1.h"
42 #include "E2SM-KPM-ActionDefinition.h"
43 #include "E2SM-KPM-EventTriggerDefinition-Format1.h"
44 #include "E2SM-KPM-EventTriggerDefinition.h"
45 #include "E2connectionUpdate-Item.h"
47 /*******************************************************************
49 * @brief Printing Type and Cause of failure
53 * Function : printE2ErrorCause
55 * Functionality: Printing Type and Cause of failure
57 * @params[in] E2 Cause
60 ******************************************************************/
62 void printE2ErrorCause(CauseE2_t *cause)
64 switch(cause->present)
66 case CauseE2_PR_ricRequest:
68 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Request", cause->choice.ricRequest);
71 case CauseE2_PR_ricService:
73 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Service", cause->choice.ricService);
76 case CauseE2_PR_e2Node:
78 DU_LOG("Failure_Type [%s] Cause [%ld]", "E2_Node", cause->choice.e2Node);
81 case CauseE2_PR_transport:
83 DU_LOG("Failure_Type [%s] Cause [%ld]", "Transport", cause->choice.transport);
86 case CauseE2_PR_protocol:
88 DU_LOG("Failure_Type [%s] Cause [%ld]", "Protocol", cause->choice.protocol);
93 DU_LOG("Failure_Type [%s] Cause [%ld]", "Miscellaneous", cause->choice.misc);
98 DU_LOG("Failure_Type and Cause unknown");
104 /*******************************************************************
106 * @brief fill E2 failure cause
110 * Function : fillE2FailureCause
112 * Functionality: fill E2 failure cause
113 * @return ROK - success
116 ******************************************************************/
118 void fillE2FailureCause(CauseE2_t *cause, CauseE2_PR causePresent, uint8_t reason)
120 cause->present = causePresent;
122 switch(cause->present)
124 case CauseE2_PR_ricRequest:
125 cause->choice.ricRequest = reason;
127 case CauseE2_PR_ricService:
128 cause->choice.ricService = reason;
130 case CauseE2_PR_e2Node:
131 cause->choice.e2Node = reason;
133 case CauseE2_PR_transport:
134 cause->choice.transport = reason;
136 case CauseE2_PR_protocol:
137 cause->choice.protocol = reason;
139 case CauseE2_PR_misc:
140 cause->choice.misc = reason;
143 cause->choice.misc = CauseE2Misc_unspecified;
148 /*******************************************************************
150 * @brief Assigns new transaction id to RIC initiated procedure
154 * Function : assignTransactionId
156 * Functionality: Assigns new transaction id to a RIC initiated
159 * @params[in] Region region
161 * @return ROK - success
164 * ****************************************************************/
166 uint8_t assignTransactionId(DuDb *duDb)
168 uint8_t currTransId = duDb->ricTransIdCounter;
170 /* Update to next valid value */
171 duDb->ricTransIdCounter++;
172 if(duDb->ricTransIdCounter == MAX_NUM_TRANSACTION)
173 duDb->ricTransIdCounter = 0;
178 /*******************************************************************
180 * @brief Sends E2 msg over SCTP
184 * Function : SendE2APMsg
186 * Functionality: Sends E2 msg over SCTP
188 * @params[in] Region region
190 * @return ROK - success
193 * ****************************************************************/
195 uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId)
199 if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
201 if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
203 ODU_PRINT_MSG(mBuf, 0,0);
205 if(sctpSend(duId, mBuf) != ROK)
207 DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
208 ODU_PUT_MSG_BUF(mBuf);
214 DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
215 ODU_PUT_MSG_BUF(mBuf);
218 ODU_PUT_MSG_BUF(mBuf);
222 DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
229 /*******************************************************************
231 * @brief Deallocate the memory allocated for RemovalRequest msg
235 * Function : FreeRemovalRequest
238 * - freeing the memory allocated for RemovalRequest
240 * @params[in] E2AP_PDU_t *e2apMsg
241 * @return ROK - success
244 * ****************************************************************/
245 void FreeRemovalRequest(E2AP_PDU_t *e2apMsg)
248 E2RemovalRequest_t *removalReq = NULLP;
252 if(e2apMsg->choice.initiatingMessage != NULLP)
254 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
255 if(removalReq->protocolIEs.list.array)
257 for(ieIdx = 0; ieIdx < removalReq->protocolIEs.list.count; ieIdx++)
259 RIC_FREE(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
261 RIC_FREE(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
263 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
265 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
269 /*******************************************************************
271 * @brief Build and send the removal request msg
275 * Function : BuildAndSendRemovalRequest
278 * - Buld and send the removal request msg to E2 node
284 * @return ROK - success
287 * ****************************************************************/
288 uint8_t BuildAndSendRemovalRequest(DuDb *duDb)
290 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
291 uint8_t ret = RFAILED;
292 E2AP_PDU_t *e2apMsg = NULLP;
293 E2RemovalRequest_t *removalReq = NULLP;
294 asn_enc_rval_t encRetVal; /* Encoder return value */
296 DU_LOG("\nINFO --> E2AP : Building Removal Request\n");
300 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
303 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
307 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
308 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
309 if(e2apMsg->choice.initiatingMessage == NULLP)
311 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
315 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2removal;
316 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
317 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2RemovalRequest;
318 removalReq = &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest;
321 removalReq->protocolIEs.list.count = elementCnt;
322 removalReq->protocolIEs.list.size = elementCnt * sizeof(E2RemovalRequestIEs_t *);
324 RIC_ALLOC(removalReq->protocolIEs.list.array, removalReq->protocolIEs.list.size);
325 if(!removalReq->protocolIEs.list.array)
327 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
331 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
333 RIC_ALLOC(removalReq->protocolIEs.list.array[ieIdx], sizeof(E2RemovalRequestIEs_t));
334 if(!removalReq->protocolIEs.list.array[ieIdx])
336 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
341 /* In case of failure */
342 if(ieIdx < elementCnt)
346 removalReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
347 removalReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
348 removalReq->protocolIEs.list.array[ieIdx]->value.present = E2RemovalRequestIEs__value_PR_TransactionID;
349 transId = assignTransactionId(duDb);
350 removalReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
352 /* Prints the Msg formed */
353 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
355 memset(encBuf, 0, ENC_BUF_MAX_LEN);
357 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
359 if(encRetVal.encoded == ENCODE_FAIL)
361 DU_LOG("\nERROR --> E2AP : Could not encode removal request structure (at %s)\n",\
362 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
367 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for removal request\n");
368 #ifdef DEBUG_ASN_PRINT
369 for(int i=0; i< encBufSize; i++)
371 printf("%x",encBuf[i]);
375 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
377 DU_LOG("\nERROR --> E2AP : Sending removal request failed");
386 /* Free all memory */
387 FreeRemovalRequest(e2apMsg);
391 /*******************************************************************
393 * @brief Fetches RAN Function DB
397 * Function : fetchRanFuncFromRanFuncId
399 * Functionality: Fetches RAN function DB from E2AP DB using
402 * @params[in] RAN Function ID
403 * @return RAN Function DB
404 * NULL, in case of failure
406 * ****************************************************************/
407 RanFunction *fetchRanFuncFromRanFuncId(DuDb *duDb, uint16_t ranFuncId)
409 RanFunction *ranFuncDb = NULLP;
411 /* Fetch RAN Function DB */
412 if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
414 ranFuncDb = &duDb->ranFunction[ranFuncId-1];
418 DU_LOG("\nERROR --> DU_APP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId);
424 /*******************************************************************
426 * @brief Fetch subscripton DB
430 * Function : fetchSubsInfoFromRicReqId
432 * Functionality: Fetches subscription DB from RAN Function DB
433 * using RIC Request ID
435 * @params[in] RIC Request ID
437 * Pointer to RIC Subscription node to be searched
438 * @return RIC Subscription from RAN Function's subcription list
439 * NULL, in case of failure
441 * ****************************************************************/
442 RicSubscription *fetchSubsInfoFromRicReqId(RicRequestId ricReqId, RanFunction *ranFuncDb, CmLList **ricSubscriptionNode)
444 RicSubscription *ricSubscriptionInfo = NULLP;
446 /* Fetch subscription detail in RAN Function DB */
447 CM_LLIST_FIRST_NODE(&ranFuncDb->subscriptionList, *ricSubscriptionNode);
448 while(*ricSubscriptionNode)
450 ricSubscriptionInfo = (RicSubscription *)((*ricSubscriptionNode)->node);
451 if(ricSubscriptionInfo && (ricSubscriptionInfo->requestId.requestorId == ricReqId.requestorId) &&
452 (ricSubscriptionInfo->requestId.instanceId == ricReqId.instanceId))
456 *ricSubscriptionNode = (*ricSubscriptionNode)->next;
457 ricSubscriptionInfo = NULLP;
460 if(!ricSubscriptionInfo)
462 DU_LOG("\nERROR --> E2AP : fetchSubsInfoFromRicReqId: Subscription not found for Requestor ID [%d] \
463 Instance ID [%d] in RAN Function ID [%d]", ricReqId.requestorId, ricReqId.instanceId, ranFuncDb->id);
466 return ricSubscriptionInfo;
469 /*******************************************************************
471 * @brief Fetch Action details
475 * Function : fetchActionInfoFromActionId
477 * Functionality: Fetch action details from RIC subscription DB
480 * @params[in] Action ID
481 * RIC Subscription DB
482 * @return Action Info DB
483 * NULL, in case of failure
485 * ****************************************************************/
486 ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo)
488 ActionInfo *actionInfoDb = NULLP;
489 if(ricSubscriptionInfo->actionSequence[actionId].actionId == actionId)
491 actionInfoDb = &ricSubscriptionInfo->actionSequence[actionId];
495 DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
496 subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
497 ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
503 /******************************************************************
505 * @brief Search E2 node component with the help of interface type
510 * Function : fetchE2NodeComponentInfo
512 * Functionality: Search E2 node component
517 * Pointer to E2 component node to be searched
520 * ****************************************************************/
522 E2NodeComponent *fetchE2NodeComponentInfo(DuDb *duDb, InterfaceType interfaceType,CmLList **e2ComponentNode)
524 E2NodeComponent *e2NodeComponentInfo=NULLP;
526 if(duDb->e2NodeComponent.count)
528 CM_LLIST_FIRST_NODE(&duDb->e2NodeComponent, *e2ComponentNode);
529 while(*e2ComponentNode)
531 e2NodeComponentInfo = (E2NodeComponent*)((*e2ComponentNode)->node);
532 if((e2NodeComponentInfo->interfaceType == interfaceType))
537 *e2ComponentNode = (*e2ComponentNode)->next;
538 e2NodeComponentInfo = NULLP;
541 return e2NodeComponentInfo;
544 /*******************************************************************
546 * @brief update E2 node config list
550 * Function : updateE2NodeConfigList
553 * - update E2 node config list
557 * Configuration which need to update in Database
559 * @return ROK - success
562 * ****************************************************************/
563 uint8_t updateE2NodeConfigList(DuDb **duDb, uint8_t protocolId, E2NodeConfigItem *tmpCfg)
566 E2NodeComponent * e2NodeComponentInfo;
567 bool configFound= false;
571 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
573 /* Adding the new e2 node component in DB*/
574 RIC_ALLOC(e2NodeComponentInfo, sizeof(E2NodeComponent));
575 e2NodeComponentInfo->interfaceType = tmpCfg->componentInfo.interfaceType;
576 e2NodeComponentInfo->componentId =tmpCfg->componentInfo.componentId;
577 RIC_ALLOC(node, sizeof(CmLList));
580 node->node = (PTR) e2NodeComponentInfo;
581 cmLListAdd2Tail(&(*duDb)->e2NodeComponent, node);
586 DU_LOG("\nERROR --> E2AP : Memory allocation failed for e2NodeComponentList node");
587 RIC_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
592 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
594 /* searching for information in a database */
595 e2NodeComponentInfo = fetchE2NodeComponentInfo((*duDb),tmpCfg->componentInfo.interfaceType, &node);
596 if(!e2NodeComponentInfo)
598 DU_LOG("\nERROR --> E2AP : Failed to find the e2 component node");
601 /* If the node is present then update the value */
602 e2NodeComponentInfo->componentId =tmpCfg->componentInfo.componentId;
606 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
608 /* searching for information in a database */
609 e2NodeComponentInfo = fetchE2NodeComponentInfo((*duDb),tmpCfg->componentInfo.interfaceType, &node);
610 if(!e2NodeComponentInfo)
612 DU_LOG("\nERROR --> E2AP : Failed to find the e2 component node");
615 /* Delete the node from the list */
616 e2NodeComponentInfo->componentId = tmpCfg->componentInfo.componentId;
617 cmLListDelFrm(&(*duDb)->e2NodeComponent, node);
618 RIC_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
624 /* If the configuration update was successful, then mark the isSuccessful as
625 * true; otherwise, mark it as false. */
626 if(configFound == true)
627 tmpCfg->isSuccessful = true;
629 tmpCfg->isSuccessful = false;
634 /*******************************************************************
636 * @brief Handling the E2 node configuration depending on the add,
637 * update, or remove configuration type
641 * Function : handleE2NodeComponentAction
644 * - Handling the E2 node configuration depending on the add,
645 * update, or remove configuration type
648 * Pointer to e2NodeCfg which has info
650 * E2NodeConfigItem to be filled
652 * @return ROK - success
655 * ****************************************************************/
657 uint8_t handleE2NodeComponentAction(DuDb *duDb, PTR e2NodeCfg, uint8_t protocolId, E2NodeConfigItem *storeCfg)
659 uint8_t configFound = ROK;
660 E2NodeConfigItem tmpCfg;
661 E2nodeComponentID_t componentId;
662 E2nodeComponentInterfaceType_t interface;
663 E2nodeComponentConfigAddition_Item_t *addCfg=NULL;
664 E2nodeComponentConfigUpdate_Item_t *updateCfg=NULL;
665 E2nodeComponentConfigRemoval_Item_t *removeCfg=NULL;
667 /* fetching the interface and component id information from the e2NodeCfg */
668 memset(storeCfg, 0, sizeof(E2NodeConfigItem));
669 storeCfg->isSuccessful=false;
670 memset(&tmpCfg, 0, sizeof(E2NodeConfigItem));
674 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
676 addCfg = (E2nodeComponentConfigAddition_Item_t *)e2NodeCfg;
677 interface = addCfg->e2nodeComponentInterfaceType;
678 componentId = addCfg->e2nodeComponentID;
681 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
683 updateCfg = (E2nodeComponentConfigUpdate_Item_t *)e2NodeCfg;
684 interface = updateCfg->e2nodeComponentInterfaceType;
685 componentId = updateCfg->e2nodeComponentID;
688 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
690 removeCfg = (E2nodeComponentConfigRemoval_Item_t*)e2NodeCfg;
691 interface = removeCfg->e2nodeComponentInterfaceType;
692 componentId = removeCfg->e2nodeComponentID;
697 /* Storing the information in temporary structure */
698 tmpCfg.componentInfo.interfaceType = interface;
700 switch(componentId.present)
702 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
704 if(componentId.choice.e2nodeComponentInterfaceTypeF1)
706 tmpCfg.componentInfo.componentId = componentId.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
716 /* Updating the database configuration */
717 configFound = updateE2NodeConfigList(&duDb, protocolId, &tmpCfg);
719 memcpy(storeCfg, &tmpCfg,sizeof(E2NodeConfigItem));
724 /*******************************************************************
726 * @brief deallocate memory allocated in E2 Node Config Update Failure
730 * Function : FreeE2ConfigUpdateFail
732 * Functionality: deallocate memory allocated in E2 Node Config Update Failure
734 * @params[in] E2AP_PDU_t *e2apMsg
737 * ****************************************************************/
739 void FreeE2ConfigUpdateFail(E2AP_PDU_t *e2apMsg)
742 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
746 if(e2apMsg->choice.unsuccessfulOutcome)
748 e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
749 if(e2NodeCfgUpdFail->protocolIEs.list.array)
751 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
753 RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateFailure_IEs_t));
755 RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array, e2NodeCfgUpdFail->protocolIEs.list.size);
757 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
759 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
763 /*******************************************************************
765 * @brief Buld and send the E2 Node Config Update failure
769 * Function : BuildAndSendE2NodeConfigUpdateFailure
772 * - Buld and send the E2 Node Config Update failure
773 * @return ROK - success
776 * ****************************************************************/
778 uint8_t BuildAndSendE2NodeConfigUpdateFailure(uint32_t duId, uint8_t transId, uint8_t causeInfo, uint8_t causeReason)
780 E2AP_PDU_t *e2apMsg = NULL;
781 asn_enc_rval_t encRetVal;
783 uint8_t elementCnt=0;
784 bool memAllocFailed = false;
785 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdateFail=NULL;
787 DU_LOG("\nINFO --> E2AP : Building E2 Node Config Update failure\n");
790 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
793 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
796 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
797 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
798 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
800 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
804 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
805 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
806 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure;
807 e2NodeCfgUpdateFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
810 e2NodeCfgUpdateFail->protocolIEs.list.count = elementCnt;
811 e2NodeCfgUpdateFail->protocolIEs.list.size = elementCnt * sizeof(struct E2nodeConfigurationUpdateFailure_IEs *);
813 RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array, e2NodeCfgUpdateFail->protocolIEs.list.size);
814 if(e2NodeCfgUpdateFail->protocolIEs.list.array == NULLP)
816 DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure array failed");
820 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
822 RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx], sizeof(struct E2nodeConfigurationUpdateFailure_IEs));
823 if(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx] == NULLP)
825 DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure IEs failed");
826 memAllocFailed = true;
831 if(memAllocFailed == true)
838 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
839 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
840 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
841 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
844 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
845 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
846 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
847 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = causeInfo;
848 if(causeInfo == CauseE2_PR_e2Node)
849 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.e2Node = causeReason;
851 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.misc = causeReason;
854 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
855 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
856 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
857 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
859 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
860 memset(encBuf, 0, ENC_BUF_MAX_LEN);
862 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
864 /* Check encode results */
865 if(encRetVal.encoded == ENCODE_FAIL)
867 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node Config Update failure structure (at %s)\n",\
868 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
873 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node Config Update Failure\n");
874 for(int i=0; i< encBufSize; i++)
876 DU_LOG("%x",encBuf[i]);
880 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
882 DU_LOG("\nERROR --> E2AP : Sending E2 Node Config Update Failure failed");
888 FreeE2ConfigUpdateFail(e2apMsg);
892 /*******************************************************************
894 * @brief process the E2 node configuration update
898 * Function : ProcE2NodeConfigUpdate
900 * Functionality: Process E2 node configuration update
904 * Pointer to E2nodeConfigurationUpdate
907 ******************************************************************/
909 void ProcE2NodeConfigUpdate(uint32_t duId, E2nodeConfigurationUpdate_t *e2NodeConfigUpdate)
912 E2NodeConfigList tmpE2NodeList;
914 uint8_t ieIdx = 0, duIdx = 0, elementCnt=0, transId = 0;
915 E2nodeComponentConfigAddition_List_t *e2NodeAddList=NULL;
916 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe=NULL;
917 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
918 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList=NULLP;
919 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe=NULLP;
920 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULLP;
921 E2nodeComponentConfigRemoval_List_t *e2NodeRemoveList=NULL;
922 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItemIe=NULL;
923 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
925 SEARCH_DU_DB(duIdx, duId, duDb);
928 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
932 memset(&tmpE2NodeList, 0, sizeof(E2NodeConfigList));
933 if(!e2NodeConfigUpdate)
935 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate pointer is null");
938 if(!e2NodeConfigUpdate->protocolIEs.list.array)
940 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate array pointer is null");
944 elementCnt = e2NodeConfigUpdate->protocolIEs.list.count;
945 for(ieIdx=0; ieIdx < e2NodeConfigUpdate->protocolIEs.list.count; ieIdx++)
947 if(!e2NodeConfigUpdate->protocolIEs.list.array[ieIdx])
949 DU_LOG("\nERROR --> E2AP : e2NodeConfigUpdate array idx %d pointer is null",arrIdx);
953 switch(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->id)
955 case ProtocolIE_IDE2_id_TransactionID:
957 transId = e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
958 if(transId < 0 || transId > 255)
960 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
966 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
968 e2NodeAddList =&e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigAddition_List;
969 if(e2NodeAddList->list.array)
971 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
973 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
974 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
975 /* Storing the E2 node information in DB */
976 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeAddItem, ProtocolIE_IDE2_id_E2nodeComponentConfigAddition,\
977 &tmpE2NodeList.addedE2Node[tmpE2NodeList.addedE2NodeCount++]) != ROK)
979 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
986 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
988 e2NodeUpdateList =&e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigUpdate_List;
989 if(e2NodeUpdateList->list.array)
991 for(arrIdx = 0; arrIdx< e2NodeUpdateList->list.count; arrIdx++)
993 e2NodeUpdateItemIe = (E2nodeComponentConfigUpdate_ItemIEs_t*) e2NodeUpdateList->list.array[arrIdx];
994 e2NodeUpdateItem = &e2NodeUpdateItemIe->value.choice.E2nodeComponentConfigUpdate_Item;
996 /* Updating the E2 node information in DB */
997 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeUpdateItem, ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate,\
998 &tmpE2NodeList.updatedE2Node[tmpE2NodeList.updatedE2NodeCount++]) != ROK)
1000 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1007 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
1009 e2NodeRemoveList = &e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2nodeComponentConfigRemoval_List;
1010 if(e2NodeRemoveList->list.array)
1012 for(arrIdx = 0; arrIdx< e2NodeRemoveList->list.count; arrIdx++)
1014 e2NodeRemovalItemIe = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemoveList->list.array[arrIdx];
1015 e2NodeRemovalItem = &e2NodeRemovalItemIe->value.choice.E2nodeComponentConfigRemoval_Item;
1017 /* Removing the E2 node information in DB */
1018 if(handleE2NodeComponentAction(duDb, (PTR)e2NodeRemovalItem, ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval,\
1019 &tmpE2NodeList.removedE2Node[tmpE2NodeList.removedE2NodeCount++]) != ROK)
1021 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",arrIdx);
1034 /* If all of the IEs are processed successfully, we will send an e2 node
1035 * config update ack message.
1036 * else we will be sendinf e2 node config update failure */
1037 if(elementCnt == ieIdx)
1039 if(BuildAndSendE2NodeConfigUpdateAck(duDb, transId, &tmpE2NodeList) !=ROK)
1041 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 node config ack");
1047 if(BuildAndSendE2NodeConfigUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
1049 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 node config Failure");
1054 /*******************************************************************
1056 * @brief Builds Global RIC Id Params
1060 * Function : BuildGlobalRicId
1062 * Functionality: Building the Plmn and ric id
1064 * @params[in] GlobalRIC_ID_t *ricId
1065 * @return ROK - success
1068 * ****************************************************************/
1070 uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId)
1073 uint8_t byteSize = 3;
1077 ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
1078 RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
1079 buildPlmnId(ricCb.ricCfgParams.plmn , ricId->pLMN_Identity.buf);
1081 ricId->ric_ID.size = byteSize * sizeof(uint8_t);
1082 RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
1083 fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
1088 /*******************************************************************
1090 * @brief deallocate the memory allocated in E2SetupResponse
1094 * Function : FreeE2SetupRsp
1096 * Functionality: deallocate the memory allocated in E2SetupResponse
1098 * @params[in] E2AP_PDU_t *e2apMsg
1101 * ****************************************************************/
1102 void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
1104 uint8_t arrIdx = 0, e2NodeConfigIdx=0, ranFuncIdx=0;
1105 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
1106 E2setupResponse_t *e2SetupRsp=NULL;
1107 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULL;
1108 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULL;
1109 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULL;
1113 if(e2apMsg->choice.successfulOutcome)
1115 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
1116 if(e2SetupRsp->protocolIEs.list.array)
1118 for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
1120 switch(e2SetupRsp->protocolIEs.list.array[arrIdx]->id)
1122 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
1124 ranFuncAcceptedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
1125 if(ranFuncAcceptedList->list.array)
1127 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
1129 if(ranFuncAcceptedList->list.array[ranFuncIdx])
1131 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1134 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
1138 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1140 e2NodeConfigAdditionAckList =&e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
1141 if(e2NodeConfigAdditionAckList->list.count)
1143 for(e2NodeConfigIdx=0; e2NodeConfigIdx<e2NodeConfigAdditionAckList->list.count; e2NodeConfigIdx++)
1145 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2NodeConfigIdx];
1146 if(e2NodeAddAckItemIe)
1148 f1InterfaceInfo = e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
1151 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
1152 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
1154 RIC_FREE(e2NodeAddAckItemIe, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
1157 RIC_FREE(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
1162 RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
1164 RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
1166 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1168 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1172 /*******************************************************************
1174 * @brief fill e2 node configuration for ack msg
1178 * Function : fillE2NodeConfigAck
1181 * - fill e2 node configuration for ack msg
1184 * Pointer to e2NodeCfg to be filled
1186 * E2 Node Component information
1187 * Is successful or failure response
1188 * @return ROK - success
1191 * ****************************************************************/
1193 uint8_t fillE2NodeConfigAck(PTR e2NodeCfg, uint8_t procedureCode, E2NodeComponent *componentInfo, bool isSuccessful)
1195 E2nodeComponentID_t *e2nodeComponentID=NULLP;
1196 E2nodeComponentInterfaceType_t *e2nodeComponentInterfaceType=NULLP;
1197 E2nodeComponentConfigurationAck_t *e2nodeComponentConfigurationAck=NULLP;
1198 E2nodeComponentConfigRemovalAck_Item_t *removalAckItem=NULLP;
1199 E2nodeComponentConfigUpdateAck_Item_t *updateAckItem=NULLP;
1200 E2nodeComponentConfigAdditionAck_Item_t *additionAckItem=NULLP;
1202 /* filling the interface type, component id, configuration ack based on the
1203 * e2 node configuration add, update, delete type */
1204 switch(procedureCode)
1206 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1208 additionAckItem = (E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg;
1209 e2nodeComponentInterfaceType = &((E2nodeComponentConfigAdditionAck_Item_t *)e2NodeCfg)->e2nodeComponentInterfaceType;
1210 e2nodeComponentID = &additionAckItem->e2nodeComponentID;
1211 e2nodeComponentConfigurationAck = &additionAckItem->e2nodeComponentConfigurationAck;
1214 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
1216 updateAckItem = (E2nodeComponentConfigUpdateAck_Item_t*) e2NodeCfg;
1217 e2nodeComponentInterfaceType = &updateAckItem->e2nodeComponentInterfaceType;
1218 e2nodeComponentID = &updateAckItem->e2nodeComponentID;
1219 e2nodeComponentConfigurationAck = &updateAckItem->e2nodeComponentConfigurationAck;
1222 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
1224 removalAckItem= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
1225 e2nodeComponentInterfaceType = &removalAckItem->e2nodeComponentInterfaceType;
1226 e2nodeComponentID = &removalAckItem->e2nodeComponentID;
1227 e2nodeComponentConfigurationAck = &removalAckItem->e2nodeComponentConfigurationAck;
1232 /* >E2 Node Component interface type */
1233 if(componentInfo->interfaceType>=NG && componentInfo->interfaceType<=X2)
1235 *e2nodeComponentInterfaceType = componentInfo->interfaceType;
1239 DU_LOG("\nERROR --> E2AP: Received an invalid interface value %d",componentInfo->interfaceType);
1243 if(*e2nodeComponentInterfaceType == E2nodeComponentInterfaceType_f1)
1245 /* >E2 Node Component ID */
1246 e2nodeComponentID->present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
1247 RIC_ALLOC(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
1248 if(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
1250 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1253 e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
1254 RIC_ALLOC(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1256 if(e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
1258 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1261 e2nodeComponentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = componentInfo->componentId;
1266 /* >E2 Node Component Configuration Acknowledge*/
1267 e2nodeComponentConfigurationAck->updateOutcome = E2nodeComponentConfigurationAck__updateOutcome_success;
1271 /* >E2 Node Component Configuration Acknowledge*/
1272 e2nodeComponentConfigurationAck->updateOutcome = E2nodeComponentConfigurationAck__updateOutcome_failure;
1273 RIC_ALLOC(e2nodeComponentConfigurationAck->failureCauseE2, sizeof(struct CauseE2));
1274 if(e2nodeComponentConfigurationAck->failureCauseE2)
1276 fillE2FailureCause(e2nodeComponentConfigurationAck->failureCauseE2, CauseE2_PR_e2Node, CauseE2node_e2node_component_unknown);
1280 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
1287 /*******************************************************************
1289 * @brief Build E2node Component config addition ack list
1293 * Function : BuildE2nodeComponentConfigAdditionAck
1295 * Functionality: Build E2node Component config addition ack list
1298 * E2nodeComponentConfigAdditionAck_List to be filled
1299 * Count of e2 node to be added
1300 * list of e2 node cfg to be added
1302 * @return ROK - success
1304 * ****************************************************************/
1306 uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, \
1307 uint16_t addedE2NodeCount, E2NodeConfigItem *addedE2Node)
1309 E2NodeComponent *e2NodeComponentInfo=NULLP;
1310 CmLList *node=NULLP;
1311 uint16_t arrIdx = 0;
1312 E2nodeComponentConfigAdditionAck_Item_t *e2NodeAddAckItem=NULLP;
1313 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULLP;
1315 e2NodeConfigAdditionAckList->list.count = addedE2NodeCount;
1317 e2NodeConfigAdditionAckList->list.size = e2NodeConfigAdditionAckList->list.count * sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t*);
1318 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
1319 if(e2NodeConfigAdditionAckList->list.array == NULLP)
1321 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
1325 for(arrIdx = 0; arrIdx< e2NodeConfigAdditionAckList->list.count; arrIdx++)
1327 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
1328 if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
1330 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
1333 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[arrIdx];
1334 e2NodeAddAckItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
1335 e2NodeAddAckItemIe->criticality = CriticalityE2_reject;
1336 e2NodeAddAckItemIe->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_E2nodeComponentConfigAdditionAck_Item;
1337 e2NodeAddAckItem = &e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item;
1339 /* Filling the e2 node config addition ack item */
1340 fillE2NodeConfigAck((PTR)&e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck,\
1341 &addedE2Node[arrIdx].componentInfo, addedE2Node[arrIdx].isSuccessful);
1346 /*******************************************************************
1348 * @brief Build RAN function accepted list
1352 * Function : BuildRanFunctionAcceptedList
1354 * Functionality: Build RAN function accepted list
1355 * ->For ProcedureCodeE2_id_E2setup or ProcedureCodeE2_id_RICserviceQuery
1356 * we add all the RAN Function list which is present in RIC database.
1357 * ->For any other procedures, we just fill the RAN functions whose ID
1358 * is present in the recvList
1362 * Count of ran functions to be accepted in the list
1363 * Received list of RAN functions
1367 * @return ROK - success
1369 * ****************************************************************/
1371 uint8_t BuildRanFunctionAcceptedList(DuDb *duDb, uint8_t count, RanFunction *ranFunAcceptedList, RANfunctionsID_List_t *ranFuncAcceptedList, uint8_t procedureCode)
1373 uint16_t ranFuncIdx = 0;
1374 RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL;
1376 /* For ProcedureCodeE2_id_E2setup and ProcedureCodeE2_id_RICserviceQuery,
1377 * the number of RAN function list items is equal to the number of
1378 * ran function entries stored in the database.
1379 * For any other procedure, the RAN function list count is equal
1380 * to the count of ran functions obtained from the function's caller */
1382 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
1383 ranFuncAcceptedList->list.count = duDb->numOfRanFunction;
1385 ranFuncAcceptedList->list.count = count;
1387 ranFuncAcceptedList->list.size = ranFuncAcceptedList->list.count*sizeof(RANfunctionID_ItemIEs_t*);
1388 RIC_ALLOC(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
1389 if(ranFuncAcceptedList->list.array)
1391 for(ranFuncIdx = 0; ranFuncIdx< ranFuncAcceptedList->list.count; ranFuncIdx++)
1393 RIC_ALLOC(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1394 if(ranFuncAcceptedList->list.array[ranFuncIdx] == NULLP)
1396 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array item");
1399 ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[ranFuncIdx];
1400 ranFuncAcceptedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
1401 ranFuncAcceptedItemIe->criticality= CriticalityE2_ignore;
1402 ranFuncAcceptedItemIe->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item;
1403 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
1405 /* filling the RAN function information with the help of DuDb */
1406 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = duDb->ranFunction[ranFuncIdx].id;
1407 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= duDb->ranFunction[ranFuncIdx].revisionCounter;
1411 /* filling the the RAN function information with the help received list of RAN functions */
1412 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = ranFunAcceptedList[ranFuncIdx].id;
1413 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= ranFunAcceptedList[ranFuncIdx].revisionCounter;
1419 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array");
1425 /*******************************************************************
1427 * @brief Builds and sends the E2SetupResponse
1431 * Function : BuildAndSendE2SetupRsp
1433 * Functionality: Builds and sends the E2SetupResponse
1438 * List of E2node cofniguration which needs to be send
1440 * @return ROK - success
1443 * ****************************************************************/
1445 uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId, E2NodeConfigList e2NodeList)
1447 E2AP_PDU_t *e2apMsg = NULL;
1448 E2setupResponse_t *e2SetupRsp;
1449 asn_enc_rval_t encRetVal;
1452 bool memAllocFailed = false;
1454 DU_LOG("\nINFO --> E2AP : Building E2 Setup Response\n");
1457 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1458 if(e2apMsg == NULLP)
1460 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1463 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1464 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1465 if(e2apMsg->choice.successfulOutcome == NULLP)
1467 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1471 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
1472 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1473 e2apMsg->choice.successfulOutcome->value.present = \
1474 SuccessfulOutcomeE2__value_PR_E2setupResponse;
1475 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
1478 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
1479 if(duDb->numOfRanFunction)
1482 e2SetupRsp->protocolIEs.list.count = elementCnt;
1483 e2SetupRsp->protocolIEs.list.size = elementCnt * sizeof(E2setupResponseIEs_t*);
1485 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
1486 if(e2SetupRsp->protocolIEs.list.array == NULLP)
1488 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
1492 for(idx=0; idx<elementCnt; idx++)
1494 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], sizeof(E2setupResponseIEs_t));
1495 if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
1497 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
1498 memAllocFailed = true;
1503 if(memAllocFailed == true)
1505 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
1510 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_TransactionID;
1511 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1512 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_TransactionID;
1513 e2SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID = transId;
1517 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID;
1518 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1519 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_GlobalRIC_ID;
1521 if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK)
1523 DU_LOG("\nERROR --> E2AP : Failed to build Global Ric Id");
1527 if(duDb->numOfRanFunction)
1529 /* Accepted RAN function Id */
1531 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
1532 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1533 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List;
1534 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_E2setup)!=ROK)
1536 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
1541 /* E2 Node Component Configuration Addition Acknowledge List*/
1543 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
1544 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1545 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
1546 E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List;
1547 if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->\
1548 value.choice.E2nodeComponentConfigAdditionAck_List, e2NodeList.addedE2NodeCount, e2NodeList.addedE2Node) != ROK)
1550 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
1554 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1555 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1557 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1559 /* Check encode results */
1560 if(encRetVal.encoded == ENCODE_FAIL)
1562 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
1563 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1568 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
1569 for(int i=0; i< encBufSize; i++)
1571 DU_LOG("%x",encBuf[i]);
1575 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
1577 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
1583 FreeE2SetupRsp(e2apMsg);
1584 BuildAndSendRicSubscriptionReq(duDb);
1588 /*******************************************************************
1590 * @brief Free RIC Subscription Details
1594 * Function : FreeRicSubsDetails
1596 * Functionality: Free the RIC Subscription Details
1598 * @params[in] RICsubscriptionDetails_t *subsDetails
1601 * ****************************************************************/
1602 void FreeRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
1604 uint8_t elementIdx = 0;
1605 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
1607 RIC_FREE(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size);
1609 if(subsDetails->ricAction_ToBeSetup_List.list.array)
1611 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
1613 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
1615 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
1616 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
1618 RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf, \
1619 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size);
1620 RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
1622 RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t))
1625 RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
1629 /*******************************************************************
1631 * @brief Free RIC Subscription Request
1635 * Function : FreeRicSubscriptionReq
1637 * Functionality : Free RIC Subscription Request
1639 * @return ROK - success
1642 ******************************************************************/
1643 void FreeRicSubscriptionReq(E2AP_PDU_t *e2apRicMsg)
1646 RICsubscriptionRequest_t *ricSubscriptionReq;
1650 if(e2apRicMsg->choice.initiatingMessage)
1652 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
1653 if(ricSubscriptionReq->protocolIEs.list.array)
1655 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
1657 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
1659 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
1661 FreeRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails));
1665 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
1667 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
1669 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1671 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
1675 /*******************************************************************
1677 * @brief Builds Ric Request Id
1681 * Function : BuildNewRicRequestId
1683 * Functionality: Assign new Ric Request ID
1685 * @params[in] RIC request ID to be sent
1686 * RIC request ID stored in DB
1687 * @return ROK - success
1690 * ****************************************************************/
1692 uint8_t BuildNewRicRequestId(RICrequestID_t *ricReqId, RicRequestId *reqIdDb)
1694 static uint16_t requestorId = 0;
1695 static uint16_t instanceId = 0;
1697 if(ricReqId != NULLP)
1699 ricReqId->ricRequestorID = ++requestorId;
1700 ricReqId->ricInstanceID = ++instanceId;
1702 reqIdDb->requestorId = ricReqId->ricRequestorID;
1703 reqIdDb->instanceId = ricReqId->ricInstanceID;
1708 /*******************************************************************
1710 * @brief Free RIC Action Definition
1714 * Function : FreeRicActionDefinition
1716 * Functionality: Free RIC Action Definition
1718 * @params[in] E2SM-KPM Action definition
1721 * ****************************************************************/
1722 void FreeRicActionDefinition(E2SM_KPM_ActionDefinition_t actionDef)
1724 uint8_t elementIdx = 0;
1725 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
1726 MeasurementInfoItem_t *measItem = NULLP;
1728 switch(actionDef.actionDefinition_formats.present)
1730 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
1732 if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1)
1734 actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
1735 if(actionFormat1->measInfoList.list.array)
1737 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
1739 if(actionFormat1->measInfoList.list.array[elementIdx])
1741 measItem = actionFormat1->measInfoList.list.array[elementIdx];
1742 switch(measItem->measType.present)
1744 case MeasurementType_PR_NOTHING:
1745 case MeasurementType_PR_measID:
1747 case MeasurementType_PR_measName:
1749 RIC_FREE(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size)
1753 RIC_FREE(measItem, sizeof(MeasurementInfoItem_t));
1756 RIC_FREE(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
1758 RIC_FREE(actionFormat1, sizeof(E2SM_KPM_ActionDefinition_Format1_t));
1763 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
1764 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
1765 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
1766 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
1767 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_NOTHING:
1772 /*******************************************************************
1774 * @brief Fill RIC Action Definition
1778 * Function : fillRicActionDef
1780 * Functionality: Fill RIC Action Definition
1782 * @params[in] RIC Action definition
1786 * ****************************************************************/
1787 uint8_t fillRicActionDef(RICactionDefinition_t *ricActionDef)
1789 uint8_t ret = RFAILED;
1790 asn_enc_rval_t encRetVal;
1791 uint8_t elementCnt = 0, elementIdx = 0;
1792 char *measurementTypeName[] = {"RRU.PrbTotDl", "RRU.PrbTotUl"};
1793 E2SM_KPM_ActionDefinition_t actionDef;
1794 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
1795 MeasurementInfoItem_t *measItem = NULLP;
1799 /* Fill E2SM-KPM Action Definition Format 1 */
1801 /* RIC Stype Type */
1802 actionDef.ric_Style_Type = RIC_STYLE_TYPE;
1804 /* RIC Action Definition Format 1 */
1805 actionDef.actionDefinition_formats.present = \
1806 E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1;
1808 RIC_ALLOC(actionDef.actionDefinition_formats.choice.actionDefinition_Format1, \
1809 sizeof(E2SM_KPM_ActionDefinition_Format1_t));
1810 if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1 == NULLP)
1812 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1815 actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
1817 /* Measurement Info List */
1819 actionFormat1->measInfoList.list.count = elementCnt;
1820 actionFormat1->measInfoList.list.size = elementCnt * sizeof(MeasurementInfoItem_t *);
1821 RIC_ALLOC(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
1822 if(actionFormat1->measInfoList.list.array == NULL)
1824 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1828 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
1830 RIC_ALLOC(actionFormat1->measInfoList.list.array[elementIdx], sizeof(MeasurementInfoItem_t));
1831 if(actionFormat1->measInfoList.list.array[elementIdx] == NULLP)
1833 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1837 measItem = actionFormat1->measInfoList.list.array[elementIdx];
1838 measItem->measType.present = MeasurementType_PR_measName;
1840 measItem->measType.choice.measName.size = strlen(measurementTypeName[elementIdx]);
1841 RIC_ALLOC(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size);
1842 if(measItem->measType.choice.measName.buf == NULLP)
1844 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1847 memcpy(measItem->measType.choice.measName.buf, measurementTypeName[elementIdx], measItem->measType.choice.measName.size);
1849 if(elementIdx < elementCnt)
1852 /* Granularity Period */
1853 actionFormat1->granulPeriod = RIC_ACTION_GRANULARITY_PERIOD; /* In ms */
1855 /* Prints the Msg formed */
1856 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, &actionDef);
1858 /* Encode E2SM-KPM RIC Action Definition */
1859 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1861 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_ActionDefinition, 0, &actionDef, PrepFinalEncBuf, encBuf);
1862 if(encRetVal.encoded == ENCODE_FAIL)
1864 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM action definition structure (at %s)\n",\
1865 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1869 /* Copty encoded E2SM-KPM RIC action definition to E2AP octet string buffer */
1870 ricActionDef->size = encBufSize;
1871 RIC_ALLOC(ricActionDef->buf, encBufSize);
1872 if(ricActionDef->buf == NULLP)
1874 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1877 memcpy(ricActionDef->buf, encBuf, encBufSize);
1883 FreeRicActionDefinition(actionDef);
1887 /*******************************************************************
1889 * @brief Fills RIC Action To Be Setup Item
1893 * Function : fillActionToBeSetup
1895 * Functionality: Fill the RIC Action To Be Setup Ite,
1896 * RIC subscription DB
1898 * @params[in] RICaction_ToBeSetup_ItemIEs_t *items
1899 * @return ROK - success
1902 * ****************************************************************/
1903 uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscription *ricSubsDb)
1905 static uint8_t ricActionId = 0;
1907 if(actionItem == NULLP)
1909 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1915 actionItem->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item;
1916 actionItem->criticality = CriticalityE2_ignore;
1917 actionItem->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
1920 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId;
1921 ricSubsDb->actionSequence[ricActionId].actionId = \
1922 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
1925 /* RIC Action Type */
1926 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report;
1928 /* RIC Action Definition */
1929 RIC_ALLOC(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
1930 if(!actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
1932 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1935 if(fillRicActionDef(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) != ROK)
1937 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1941 ricSubsDb->numOfActions++;
1945 memset(&ricSubsDb->actionSequence[ricActionId], 0, sizeof(ActionInfo));
1946 ricSubsDb->actionSequence[ricActionId].actionId = -1;
1950 /*******************************************************************
1952 * @brief Free Event Trigger Definition
1956 * Function : FreeEventTriggerDef
1958 * Functionality: Free Event Trigger Definition
1960 * @params[in] E2SM-KPM Event Trigger Definition
1963 * ****************************************************************/
1964 void FreeEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
1968 switch(eventTiggerDef->eventDefinition_formats.present)
1970 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
1972 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
1973 RIC_FREE(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1, \
1974 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
1980 /*******************************************************************
1982 * @brief Fill Event Trigger Definition
1986 * Function : fillEventTriggerDef
1988 * Functionality: Fill Event Trigger Definition
1990 * @params[in] RIC Event Trigger Definition
1994 * ****************************************************************/
1995 uint8_t fillEventTriggerDef(RICeventTriggerDefinition_t *ricEventTriggerDef)
1997 uint8_t ret = RFAILED;
1998 asn_enc_rval_t encRetVal;
1999 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef;
2003 /* Fill E2SM-KPM Event Trigger Definition Format 1 */
2004 eventTiggerDef.eventDefinition_formats.present = \
2005 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1;
2007 RIC_ALLOC(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1, \
2008 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
2009 if(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1 == NULLP)
2011 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2015 eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod = 1000; /* In ms */
2017 /* Prints the Msg formed */
2018 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, &eventTiggerDef);
2020 /* Encode E2SM-KPM Event Trigger Definition */
2021 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2023 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_EventTriggerDefinition, 0, &eventTiggerDef, PrepFinalEncBuf, encBuf);
2024 if(encRetVal.encoded == ENCODE_FAIL)
2026 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM event trigger definition structure (at %s)\n",\
2027 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2031 /* Copy encoded E2SM-KPM event trigger definition to E2AP octet string buffer */
2032 ricEventTriggerDef->size = encBufSize;
2033 RIC_ALLOC(ricEventTriggerDef->buf, encBufSize);
2034 if(ricEventTriggerDef->buf == NULLP)
2036 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2039 memcpy(ricEventTriggerDef->buf, encBuf, encBufSize);
2045 FreeEventTriggerDef(&eventTiggerDef);
2049 /*******************************************************************
2051 * @brief builds RIC Subscription Details
2055 * Function : BuildsRicSubsDetails
2057 * Functionality: Builds the RIC Subscription Details
2059 * @params[in] RIC Subscription details to be filled
2060 * RIC subscriotion DB
2061 * @return ROK - success
2064 * ****************************************************************/
2066 uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails, RicSubscription *ricSubsInfo)
2068 uint8_t elementCnt = 0;
2069 uint8_t elementIdx = 0;
2071 if(subsDetails == NULLP)
2073 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2079 /* RIC Event Trigger Definition */
2080 if(fillEventTriggerDef(&subsDetails->ricEventTriggerDefinition) != ROK)
2082 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2086 /* RIC Actions To Be Setup List */
2088 subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
2089 subsDetails->ricAction_ToBeSetup_List.list.size = elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t *);
2090 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
2091 if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
2093 DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
2097 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
2099 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t));
2100 if(!subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
2102 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2106 if(elementIdx < elementCnt)
2111 if(fillActionToBeSetup((RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], \
2112 ricSubsInfo) != ROK)
2114 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
2123 /*******************************************************************
2125 * @brief Builds and Send the RicSubscriptionReq
2129 * Function : BuildAndSendRicSubscriptionReq
2131 * Functionality:Fills the RicSubscriptionReq
2133 * @return ROK - success
2136 ******************************************************************/
2137 uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb)
2139 uint8_t ret = RFAILED;
2140 uint8_t elementCnt = 0;
2142 uint8_t actionIdx = 0;
2143 asn_enc_rval_t encRetVal; /* Encoder return value */
2144 E2AP_PDU_t *e2apRicMsg = NULL;
2145 RICsubscriptionRequest_t *ricSubscriptionReq;
2146 RanFunction *ranFuncDb = &duDb->ranFunction[0];
2147 CmLList *ricSubsNode = NULLP;
2148 RicSubscription *ricSubsInfo = NULLP;
2150 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
2152 /* Allocate memory to store RIC subscription info in RIC DB */
2153 RIC_ALLOC(ricSubsInfo, sizeof(RicSubscription));
2156 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2159 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
2161 ricSubsInfo->actionSequence[actionIdx].actionId = -1;
2166 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
2167 if(e2apRicMsg == NULLP)
2169 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2173 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
2174 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2175 if(e2apRicMsg->choice.initiatingMessage == NULLP)
2177 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2180 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
2181 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2182 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
2184 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
2187 ricSubscriptionReq->protocolIEs.list.count = elementCnt;
2188 ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
2190 /* Initialize the subscription members */
2191 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
2192 if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
2194 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2198 for(idx=0; idx<elementCnt; idx++)
2200 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
2201 if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
2203 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2207 if(idx < elementCnt)
2210 /* Filling RIC Request Id */
2212 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
2213 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2214 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
2215 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
2216 if(BuildNewRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID, \
2217 &ricSubsInfo->requestId) != ROK)
2219 DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
2224 /* Filling RAN Function Id */
2226 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
2227 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2228 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
2229 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
2230 ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ranFuncDb->id;
2231 ricSubsInfo->ranFuncId = ranFuncDb->id;
2233 /* Filling RIC Subscription Details */
2235 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
2236 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2237 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
2238 RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
2239 if(BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails),\
2240 ricSubsInfo) != ROK)
2242 DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
2246 /* Prints the Msg formed */
2247 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
2249 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2251 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
2252 if(encRetVal.encoded == ENCODE_FAIL)
2254 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
2255 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2260 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
2261 for(int i=0; i< encBufSize; i++)
2263 DU_LOG("%x",encBuf[i]);
2268 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
2270 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
2274 /* Add RIC Subscription Info to RAN Function's RIC Subscription List */
2275 RIC_ALLOC(ricSubsNode , sizeof(CmLList));
2278 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
2281 ricSubsNode->node = (PTR)ricSubsInfo;
2282 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubsNode);
2290 RIC_FREE(ricSubsInfo, sizeof(RicSubscription));
2291 RIC_FREE(ricSubsNode , sizeof(CmLList));
2294 FreeRicSubscriptionReq(e2apRicMsg);
2298 /*******************************************************************
2300 * @brief Process RicSubscriptionResponse
2304 * Function : ProcRicSubscriptionRsp
2306 * Functionality: Processes RicSubscriptionRsp
2308 * @return ROK - void
2310 ******************************************************************/
2312 void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp)
2314 uint8_t duIdx = 0, ieIdx = 0, notAdmitIdx = 0;
2315 uint8_t ranFuncId = 0, actionId = 0;
2317 bool ricReqIdDecoded = false;
2318 RicRequestId ricReqId;
2319 RanFunction *ranFuncDb = NULLP;
2320 RicSubscription *ricSubs = NULLP;
2321 CmLList *ricSubsNode = NULLP;
2322 ActionInfo *action = NULLP;
2323 RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP;
2324 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
2326 DU_LOG("\nINFO --> E2AP : RIC Subscription Response received");
2329 SEARCH_DU_DB(duIdx, duId, duDb);
2332 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
2336 memset(&ricReqId, 0, sizeof(RicRequestId));
2337 if(ricSubscriptionRsp)
2339 if(ricSubscriptionRsp->protocolIEs.list.array)
2341 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
2343 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx])
2345 ricSubsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
2346 switch(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]->id)
2348 case ProtocolIE_IDE2_id_RICrequestID:
2350 ricReqId.requestorId = ricSubsRspIe->value.choice.RICrequestID.ricRequestorID;
2351 ricReqId.instanceId = ricSubsRspIe->value.choice.RICrequestID.ricInstanceID;
2352 ricReqIdDecoded = true;
2355 case ProtocolIE_IDE2_id_RANfunctionID:
2357 ranFuncId = ricSubsRspIe->value.choice.RANfunctionID;
2358 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
2361 DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId);
2366 case ProtocolIE_IDE2_id_RICactions_Admitted:
2370 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
2372 if(!(ranFuncDb && ricReqIdDecoded))
2375 notAdmitList = &ricSubsRspIe->value.choice.RICaction_NotAdmitted_List;
2376 for(notAdmitIdx = 0; notAdmitIdx < notAdmitList->list.count; notAdmitIdx++)
2378 actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\
2379 value.choice.RICaction_NotAdmitted_Item.ricActionID;
2381 /* Remove action from RAN Function's subscription list */
2382 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
2385 action = fetchActionInfoFromActionId(actionId, ricSubs);
2388 memset(action, 0, sizeof(ActionInfo));
2389 ricSubs->actionSequence[actionId].actionId = -1;
2390 ricSubs->numOfActions--;
2403 /*******************************************************************
2405 * @brief deallocate the memory allocated in E2SetupFailure
2409 * Function : FreeE2SetupFailure
2411 * Functionality: deallocate the memory allocated in E2SetupFailure
2413 * @params[in] E2AP_PDU_t *e2apMsg
2416 * ****************************************************************/
2417 void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg)
2420 E2setupFailure_t *e2SetupFail;
2424 if(e2apMsg->choice.unsuccessfulOutcome)
2426 e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
2427 if(e2SetupFail->protocolIEs.list.array)
2429 for(arrIdx=0; arrIdx<e2SetupFail->protocolIEs.list.count; arrIdx++)
2431 RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t));
2433 RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size);
2435 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
2437 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2441 /*******************************************************************
2443 * @brief Buld and send the E2 Setup failure
2447 * Function : BuildAndSendE2SetupFailure
2450 * - Buld and send the E2 Setup failure
2451 * @return ROK - success
2454 * ****************************************************************/
2456 uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId)
2458 uint8_t ret = RFAILED;
2459 E2AP_PDU_t *e2apMsg = NULL;
2460 E2setupFailure_t *e2SetupFailure;
2461 asn_enc_rval_t encRetVal;
2464 bool memAllocFailed = false;
2466 DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
2469 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2470 if(e2apMsg == NULLP)
2472 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2475 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
2476 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
2477 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
2479 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2483 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
2484 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
2485 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure;
2486 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
2489 e2SetupFailure->protocolIEs.list.count = elementCnt;
2490 e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *);
2492 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
2493 if(e2SetupFailure->protocolIEs.list.array == NULLP)
2495 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2499 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2501 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
2502 if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
2504 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2505 memAllocFailed = true;
2510 if(memAllocFailed == true)
2512 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
2518 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2519 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2520 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
2521 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2524 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
2525 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2526 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
2527 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol;
2528 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified;
2531 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
2532 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
2533 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
2534 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
2536 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2537 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2539 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2541 /* Check encode results */
2542 if(encRetVal.encoded == ENCODE_FAIL)
2544 DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
2545 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2550 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
2551 for(int i=0; i< encBufSize; i++)
2553 DU_LOG("%x",encBuf[i]);
2557 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2559 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
2567 FreeE2SetupFailure(e2apMsg);
2571 /*******************************************************************
2573 * @brief process the e2setup request
2577 * Function : ProcE2SetupReq
2579 * Functionality: process the e2setup request
2583 ******************************************************************/
2585 void ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
2587 uint8_t arrIdx = 0, duIdx = 0, transId =0;
2588 uint16_t ranFuncIdx=0, e2NodeAddListIdx =0;
2589 E2NodeConfigList tmpE2NodeList;
2591 bool ieProcessingFailed = false;
2592 E2nodeComponentConfigAddition_List_t *e2NodeAddList=NULLP;
2593 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem=NULLP;
2594 RANfunction_ItemIEs_t *ranFuncItemIe=NULLP;
2595 RANfunction_Item_t *ranFunItem=NULLP;
2596 RANfunctions_List_t *ranFunctionsList=NULLP;
2598 memset(&tmpE2NodeList, 0, sizeof(E2NodeConfigList));
2601 DU_LOG("\nERROR --> E2AP : e2SetupReq pointer is null");
2604 if(!e2SetupReq->protocolIEs.list.array)
2606 DU_LOG("\nERROR --> E2AP : e2SetupReq array pointer is null");
2610 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
2612 if(e2SetupReq->protocolIEs.list.array[arrIdx])
2614 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
2616 case ProtocolIE_IDE2_id_TransactionID:
2618 transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2621 case ProtocolIE_IDE2_id_GlobalE2node_ID:
2623 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID)
2625 *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0];
2627 SEARCH_DU_DB(duIdx, *duId, duDb);
2630 duDb = &ricCb.duInfo[ricCb.numDu];
2633 memset(duDb, 0, sizeof(DuDb));
2638 case ProtocolIE_IDE2_id_RANfunctionsAdded:
2640 ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2642 if(ranFunctionsList->list.array)
2644 for(ranFuncIdx=0;ranFuncIdx<ranFunctionsList->list.count; ranFuncIdx++)
2646 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
2647 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2648 duDb->ranFunction[ranFunItem->ranFunctionID-1].id = ranFunItem->ranFunctionID;
2649 duDb->ranFunction[ranFunItem->ranFunctionID-1].revisionCounter = ranFunItem->ranFunctionRevision;
2650 cmLListInit(&duDb->ranFunction[ranFunItem->ranFunctionID-1].subscriptionList);
2651 duDb->numOfRanFunction++;
2656 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
2658 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
2659 if(e2NodeAddList->list.array)
2661 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
2663 if(e2NodeAddList->list.array[e2NodeAddListIdx])
2665 /* Storing the E2 node information in DB */
2666 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *)e2NodeAddList->list.array[e2NodeAddListIdx];
2667 if(handleE2NodeComponentAction(duDb, (PTR)&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item,\
2668 ProtocolIE_IDE2_id_E2nodeComponentConfigAddition, &tmpE2NodeList.addedE2Node[tmpE2NodeList.addedE2NodeCount++]) != ROK)
2670 DU_LOG("\nERROR --> E2AP : Processing of E2 node component idx %d failed",e2NodeAddListIdx);
2684 if(BuildAndSendE2SetupRsp(duDb, transId, tmpE2NodeList) !=ROK)
2686 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
2689 /*******************************************************************
2691 * @brief Deallocate the memory allocated for E2 Reset Response
2695 * Function : FreeE2ResetResponse
2698 * - freeing the memory allocated for E2ResetResponse
2700 * @params[in] E2AP_PDU_t *e2apMsg
2701 * @return ROK - success
2704 * ****************************************************************/
2705 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
2708 ResetResponseE2_t *resetResponse =NULLP;
2710 if(e2apMsg != NULLP)
2712 if(e2apMsg->choice.successfulOutcome != NULLP)
2714 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
2715 if(resetResponse->protocolIEs.list.array)
2717 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
2719 if(resetResponse->protocolIEs.list.array[ieIdx])
2721 RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
2724 RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
2726 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2728 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2732 /*******************************************************************
2734 * @brief Buld and send the Reset Response msg
2738 * Function : BuildAndSendResetResponse
2741 * - Buld and send the Reset Response Message
2746 * @return ROK - success
2749 * ****************************************************************/
2750 uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId)
2752 uint8_t ieIdx = 0, elementCnt = 0;
2753 uint8_t ret = RFAILED;
2754 E2AP_PDU_t *e2apMsg = NULLP;
2755 ResetResponseE2_t *resetResponse=NULL;
2756 asn_enc_rval_t encRetVal; /* Encoder return value */
2758 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
2761 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2762 if(e2apMsg == NULLP)
2764 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
2767 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
2769 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2770 if(e2apMsg->choice.successfulOutcome == NULLP)
2772 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
2776 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
2777 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2778 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
2779 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
2782 resetResponse->protocolIEs.list.count = elementCnt;
2783 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
2784 RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
2785 if(!resetResponse->protocolIEs.list.array)
2787 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
2791 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
2793 RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
2794 if(!resetResponse->protocolIEs.list.array[ieIdx])
2796 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
2800 if(ieIdx < elementCnt)
2804 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2805 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
2806 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
2807 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
2809 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2811 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2813 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2814 if(encRetVal.encoded == ENCODE_FAIL)
2816 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
2817 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2822 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
2823 for(int i=0; i< encBufSize; i++)
2825 DU_LOG("%x",encBuf[i]);
2830 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2832 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
2840 FreeE2ResetResponse(e2apMsg);
2844 /*******************************************************************
2846 * @brief deallocate the memory allocated in building the
2847 * Service Query message
2851 * Function : FreeRicServiceQuery
2853 * Functionality: deallocate the memory allocated in building
2854 * Ric Service Query message
2856 * @params[in] E2AP_PDU_t *e2apMsg
2859 * ****************************************************************/
2861 void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg)
2863 uint8_t arrIdx = 0, ranFuncIdx=0;
2864 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
2865 RICserviceQuery_t *ricServiceQuery=NULL;
2869 if(e2apMsg->choice.initiatingMessage)
2871 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
2872 if(ricServiceQuery->protocolIEs.list.array)
2874 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
2876 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
2878 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
2880 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2882 ranFuncAcceptedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2883 if(ranFuncAcceptedList->list.array)
2885 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
2887 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
2889 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
2893 case RICserviceQuery_IEs__value_PR_TransactionID:
2898 RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
2901 RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
2903 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2905 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2909 /*******************************************************************
2911 * @brief build and send the ric service Query
2915 * Function : BuildAndSendRicServiceQuery
2917 * Functionality: build and send the ric service Query
2918 * @return ROK - success
2919 * RFAILED - Acknowledge
2921 ******************************************************************/
2923 uint8_t BuildAndSendRicServiceQuery(DuDb *duDb)
2927 uint8_t ret = RFAILED;
2928 bool memAllocFailed = false;
2929 E2AP_PDU_t *e2apMsg = NULL;
2930 asn_enc_rval_t encRetVal;
2931 RICserviceQuery_t *ricServiceQuery;
2933 DU_LOG("\nINFO --> E2AP : Building Ric service Query\n");
2936 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2937 if(e2apMsg == NULLP)
2939 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2942 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2943 RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2));
2944 if(e2apMsg->choice.initiatingMessage == NULLP)
2946 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2950 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery;
2951 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2952 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery;
2953 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
2956 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
2957 if(duDb->numOfRanFunction)
2960 ricServiceQuery->protocolIEs.list.count = elementCnt;
2961 ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*);
2963 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
2964 if(ricServiceQuery->protocolIEs.list.array == NULLP)
2966 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2970 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2972 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
2973 if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP)
2975 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2976 memAllocFailed = true;
2980 if(memAllocFailed == true)
2982 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2988 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2989 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2990 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID;
2991 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb);
2993 if(duDb->numOfRanFunction)
2995 /* Accepted RAN function Id */
2997 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
2998 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2999 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List;
3000 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK)
3002 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
3007 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3008 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3010 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3012 /* Check encode results */
3013 if(encRetVal.encoded == ENCODE_FAIL)
3015 DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
3016 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3021 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
3022 for(int i=0; i< encBufSize; i++)
3024 DU_LOG("%x",encBuf[i]);
3028 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
3030 DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed");
3037 FreeRicServiceQuery(e2apMsg);
3041 /*******************************************************************
3043 * @brief deallocate the memory allocated in RicServiceUpdateFailure
3047 * Function : FreeRicServiceUpdateFailure
3049 * Functionality: deallocate the memory allocated in RicServiceUpdatefailure
3051 * @params[in] E2AP_PDU_t *e2apMsg
3054 * ****************************************************************/
3056 void FreeRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
3059 RICserviceUpdateFailure_t *ricServiceUpdateFailure=NULL;
3063 if(e2apMsg->choice.unsuccessfulOutcome)
3065 ricServiceUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
3066 if(ricServiceUpdateFailure->protocolIEs.list.array)
3068 for(arrIdx=0; arrIdx<ricServiceUpdateFailure->protocolIEs.list.count; arrIdx++)
3070 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
3072 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array, ricServiceUpdateFailure->protocolIEs.list.size);
3074 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3076 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3080 /*******************************************************************
3082 * @brief build and send the ric service update failure
3086 * Function : BuildAndSendRicServiceUpdateFailure
3088 * Functionality: build and send the ric service update failure
3089 * @return ROK - success
3092 ******************************************************************/
3094 uint8_t BuildAndSendRicServiceUpdateFailure(uint32_t duId, int8_t transId, CauseE2_PR causePresent, uint8_t reason)
3097 E2AP_PDU_t *e2apMsg = NULL;
3098 asn_enc_rval_t encRetVal;
3099 uint8_t ret = RFAILED;
3101 uint8_t elementCnt=0;
3102 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
3104 DU_LOG("\nINFO --> E2AP : Building Ric service update failure\n");
3107 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3108 if(e2apMsg == NULLP)
3110 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3113 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3114 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
3115 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3117 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3121 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
3122 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3123 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure;
3124 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
3127 ricServiceFailure->protocolIEs.list.count = elementCnt;
3128 ricServiceFailure->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateFailure_IEs_t *);
3130 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array, ricServiceFailure->protocolIEs.list.size);
3131 if(ricServiceFailure->protocolIEs.list.array == NULLP)
3133 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3137 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3139 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
3140 if(ricServiceFailure->protocolIEs.list.array[arrIdx] == NULLP)
3142 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3146 if(arrIdx<elementCnt)
3148 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
3154 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3155 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3156 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TransactionID;
3157 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
3160 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
3161 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3162 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_CauseE2;
3163 fillE2FailureCause(&ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, causePresent, reason);
3166 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
3167 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
3168 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TimeToWaitE2;
3169 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
3171 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3172 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3174 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3176 /* Check encode results */
3177 if(encRetVal.encoded == ENCODE_FAIL)
3179 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\
3180 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3185 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n");
3186 for(int i=0; i< encBufSize; i++)
3188 DU_LOG("%x",encBuf[i]);
3192 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
3194 DU_LOG("\nERROR --> E2AP : Sending RIC service update failed");
3201 FreeRicServiceUpdateFailure(e2apMsg);
3206 /*******************************************************************
3208 * @brief deallocate the memory allocated in RicServiceUpdateAck(
3212 * Function : FreeRicServiceUpdateAck
3214 * Functionality: deallocate the memory allocated in RicServiceUpdateAck
3216 * @params[in] E2AP_PDU_t *e2apMsg
3219 * ****************************************************************/
3221 void FreeRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
3223 uint8_t arrIdx = 0, ranFuncIdx=0;
3224 RANfunctionsID_List_t *acceptedList=NULL;
3225 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
3226 RANfunctionsIDcause_List_t *rejectedList=NULL;
3230 if(e2apMsg->choice.successfulOutcome)
3232 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
3233 if(ricServiceUpdateAck->protocolIEs.list.array)
3235 for(arrIdx=0; arrIdx<ricServiceUpdateAck->protocolIEs.list.count; arrIdx++)
3237 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx])
3239 switch(ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id)
3241 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
3243 acceptedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3244 if(acceptedList->list.array)
3246 for(ranFuncIdx=0;ranFuncIdx<acceptedList->list.count; ranFuncIdx++)
3248 RIC_FREE(acceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
3250 RIC_FREE(acceptedList->list.array, acceptedList->list.size);
3255 case ProtocolIE_IDE2_id_RANfunctionsRejected:
3257 rejectedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
3258 if(rejectedList->list.array)
3260 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
3262 RIC_FREE(rejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
3264 RIC_FREE(rejectedList->list.array, rejectedList->list.size);
3269 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
3272 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
3274 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
3276 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3280 /*******************************************************************
3282 * @brief Build RAN function rejected list
3286 * Function : BuildRanFunctionRejectedList
3288 * Functionality: Build RAN function rejected list
3291 * Count of ran functions to be rejected in the list
3292 * Received list of RAN functions
3294 * @return ROK - success
3296 * ****************************************************************/
3298 uint8_t BuildRanFunctionRejectedList(uint8_t count, RanFunction *ranFunRejectedList, RANfunctionsIDcause_List_t *ranFuncRejectedList)
3300 uint8_t ranFuncIdx = 0;
3301 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
3303 ranFuncRejectedList->list.count = count;
3305 ranFuncRejectedList->list.size = ranFuncRejectedList->list.count*sizeof(RANfunctionIDcause_ItemIEs_t*);
3306 RIC_ALLOC(ranFuncRejectedList->list.array, ranFuncRejectedList->list.size);
3307 if(ranFuncRejectedList->list.array == NULLP)
3309 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array");
3313 for(ranFuncIdx = 0; ranFuncIdx< ranFuncRejectedList->list.count; ranFuncIdx++)
3315 RIC_ALLOC(ranFuncRejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
3316 if(ranFuncRejectedList->list.array[ranFuncIdx] == NULLP)
3318 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array item");
3321 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[ranFuncIdx];
3322 ranFuncRejectedItemIe->id = ProtocolIE_IDE2_id_RANfunctionIEcause_Item;
3323 ranFuncRejectedItemIe->criticality= CriticalityE2_ignore;
3324 ranFuncRejectedItemIe->value.present = RANfunctionIDcause_ItemIEs__value_PR_RANfunctionIDcause_Item;
3325 ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID = ranFunRejectedList[ranFuncIdx].id;
3326 fillE2FailureCause(&ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.cause, CauseE2_PR_ricService,\
3327 CauseE2RICservice_ran_function_not_supported);
3333 /*******************************************************************
3335 * @brief build and send the ric service update Acknowledge
3339 * Function : BuildAndSendRicServiceUpdateAcknowledge
3341 * Functionality: build and send the ric service update Acknowledge
3342 * @return ROK - success
3343 * RFAILED - Acknowledge
3345 ******************************************************************/
3347 uint8_t BuildAndSendRicServiceUpdateAcknowledge(DuDb *duDb, int8_t transId, RicTmpRanFunList ricRanFuncList)
3349 E2AP_PDU_t *e2apMsg = NULL;
3350 asn_enc_rval_t encRetVal;
3351 uint8_t arrIdx=0, elementCnt=0, ret=RFAILED;;
3352 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
3354 DU_LOG("\nINFO --> E2AP : Building Ric service update Acknowledge\n");
3357 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3358 if(e2apMsg == NULLP)
3360 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3363 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
3364 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(struct SuccessfulOutcomeE2));
3365 if(e2apMsg->choice.successfulOutcome == NULLP)
3367 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3371 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
3372 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
3373 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge;
3374 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
3377 if(ricRanFuncList.numOfRanFunAccepted)
3379 if(ricRanFuncList.numOfRanFuneRejected)
3383 ricServiceUpdateAck->protocolIEs.list.count = elementCnt;
3384 ricServiceUpdateAck->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateAcknowledge_IEs_t*);
3386 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
3387 if(ricServiceUpdateAck->protocolIEs.list.array == NULLP)
3389 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3393 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
3395 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
3396 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
3398 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3402 if(arrIdx<elementCnt)
3404 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
3410 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3411 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3412 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_TransactionID;
3413 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
3415 if(ricRanFuncList.numOfRanFunAccepted)
3417 /* Accepted RAN function List */
3419 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
3420 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3421 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsID_List;
3422 if(BuildRanFunctionAcceptedList(duDb, ricRanFuncList.numOfRanFunAccepted, ricRanFuncList.ranFunAcceptedList,\
3423 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceUpdate)!=ROK)
3425 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
3430 if(ricRanFuncList.numOfRanFuneRejected)
3432 /* RAN Functions Rejected List */
3434 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsRejected;
3435 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3436 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsIDcause_List;
3437 if(BuildRanFunctionRejectedList(ricRanFuncList.numOfRanFuneRejected, ricRanFuncList.ranFunRejectedList, \
3438 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List)!=ROK)
3440 DU_LOG("\nERROR --> E2AP : Failed to build Ran function rejected list");
3446 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3447 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3449 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3451 /* Check encode results */
3452 if(encRetVal.encoded == ENCODE_FAIL)
3454 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\
3455 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3460 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\n");
3461 for(int i=0; i< encBufSize; i++)
3463 DU_LOG("%x",encBuf[i]);
3467 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
3469 DU_LOG("\nERROR --> E2AP : Sending RIC service update ack failed");
3475 FreeRicServiceUpdateAck(e2apMsg);
3479 /*******************************************************************
3481 * @brief process the RIC service update
3485 * Function : ProcRicserviceUpdate
3487 * Functionality: process the RIC service update
3489 * @return ROK - success
3492 ******************************************************************/
3494 void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate)
3496 RicTmpRanFunList ricRanFuncList;
3499 uint8_t duIdx = 0, elementCnt =0, arrIdx = 0;
3500 uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0;
3501 RanFunction *ranFuncDb = NULLP;
3502 RANfunction_ItemIEs_t *ranFuncItemIe =NULL;
3503 RANfunction_Item_t *ranFuncItem =NULL;
3504 RANfunctionID_Item_t *ranFuncIdItem=NULL;
3505 RANfunctions_List_t *ranFuncList=NULL;
3506 RANfunctionsID_List_t *deleteList=NULL;
3507 RANfunctionID_ItemIEs_t *delRanFuncItem=NULL;
3509 SEARCH_DU_DB(duIdx, duId, duDb);
3512 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
3515 memset(&ricRanFuncList, 0, sizeof(RicTmpRanFunList));
3517 if(!ricServiceUpdate)
3519 DU_LOG("\nERROR --> E2AP : ricServiceUpdate pointer is null");
3523 if(!ricServiceUpdate->protocolIEs.list.array)
3525 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array pointer is null");
3528 elementCnt = ricServiceUpdate->protocolIEs.list.count;
3529 for(arrIdx=0; arrIdx<ricServiceUpdate->protocolIEs.list.count; arrIdx++)
3531 if(!ricServiceUpdate->protocolIEs.list.array[arrIdx])
3533 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx);
3537 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
3539 case ProtocolIE_IDE2_id_TransactionID:
3541 transId = ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
3543 if(transId < 0 || transId > 255)
3545 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
3551 case ProtocolIE_IDE2_id_RANfunctionsAdded:
3553 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
3555 if(ranFuncList->list.array)
3557 for(ranFuncIdx=0;ranFuncIdx<ranFuncList->list.count; ranFuncIdx++)
3559 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
3560 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
3562 /* Adding the ran function in temporary list */
3563 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
3564 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
3565 ricRanFuncList.numOfRanFunAccepted++;
3567 /* Adding the new ran function in DB*/
3568 duDb->ranFunction[ranFuncItem->ranFunctionID-1].id = ranFuncItem->ranFunctionID;
3569 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
3570 duDb->numOfRanFunction++;
3572 /* Calculating total number of ran fuctions which are received for addition */
3573 recvdRanFuncCount++;
3579 case ProtocolIE_IDE2_id_RANfunctionsModified:
3582 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
3583 if(ranFuncList->list.array)
3585 for(ranFuncIdx = 0; ranFuncIdx< ranFuncList->list.count; ranFuncIdx++)
3587 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
3588 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
3589 if(fetchRanFuncFromRanFuncId(duDb, ranFuncItem->ranFunctionID) == NULLP)
3591 /* Calculating total number of ran fuctions which are not present */
3592 failedRanFuncCount++;
3594 /* Adding the ran function in temporary list */
3595 ricRanFuncList.ranFunRejectedList[ricRanFuncList.numOfRanFuneRejected].id = ranFuncItem->ranFunctionID;
3596 ricRanFuncList.numOfRanFuneRejected++;
3601 /* Adding the ran function in temporary list */
3602 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
3603 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
3604 ricRanFuncList.numOfRanFunAccepted++;
3606 /* Updating the new ran function in DB*/
3607 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
3609 /* Calculating total number of ran fuctions which are received for modification */
3610 recvdRanFuncCount++;
3615 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
3618 deleteList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3619 if(deleteList->list.array)
3621 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
3623 delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx];
3624 ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item;
3625 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncIdItem->ranFunctionID);
3628 memset(ranFuncDb, 0, sizeof(RanFunction));
3629 duDb->numOfRanFunction--;
3632 /* Calculating total number of ran fuctions which are received for deletion */
3633 recvdRanFuncCount++;
3641 DU_LOG("\nERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id);
3647 /* Sending RIC Service Update Failed if all RAN Functions received fail or if any IE processing fails
3648 * Else sending RIC Service Update Acknowledge */
3649 if((elementCnt > arrIdx) ||((recvdRanFuncCount > 0) && (recvdRanFuncCount == failedRanFuncCount)))
3651 if(BuildAndSendRicServiceUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
3653 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update Failure");
3659 if(BuildAndSendRicServiceUpdateAcknowledge(duDb, transId, ricRanFuncList) != ROK)
3661 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update acknowledge");
3667 /*******************************************************************
3669 * @brief Processing RIC subscription failure from DU
3673 * Function : ProcRicSubscriptionFailure
3675 * Functionality: Processing RIC subscription failure from DU
3677 * @param ID of DU from which message was sent
3678 * RIC Subscription failure message
3679 * @return ROK - success
3682 ******************************************************************/
3683 uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricSubscriptionFailure)
3685 uint8_t ieIdx = 0, duIdx = 0;
3686 uint8_t ranFuncId = 0;
3688 RanFunction *ranFuncDb = NULLP;
3689 RicSubscription *ricSubs = NULLP;
3690 CmLList *ricSubsNode = NULLP;
3691 RicRequestId ricReqId;
3692 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3694 DU_LOG("\nINFO --> E2AP : Received RIC subscription failure");
3696 SEARCH_DU_DB(duIdx, duId, duDb);
3699 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
3703 memset(&ricReqId, 0, sizeof(RicRequestId));
3704 if(ricSubscriptionFailure)
3706 if(ricSubscriptionFailure->protocolIEs.list.array)
3708 for(ieIdx=0; ieIdx<ricSubscriptionFailure->protocolIEs.list.count; ieIdx++)
3710 if(ricSubscriptionFailure->protocolIEs.list.array[ieIdx])
3712 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[ieIdx];
3713 switch(ricSubscriptionFailure->protocolIEs.list.array[ieIdx]->id)
3715 case ProtocolIE_IDE2_id_RICrequestID:
3717 ricReqId.requestorId = ricSubsFailIe->value.choice.RICrequestID.ricRequestorID;
3718 ricReqId.instanceId = ricSubsFailIe->value.choice.RICrequestID.ricInstanceID;
3721 case ProtocolIE_IDE2_id_RANfunctionID:
3723 ranFuncId = ricSubsFailIe->value.choice.RANfunctionID;
3724 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
3727 DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId);
3732 /* Remove subscription entry from RAN Function */
3733 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
3736 cmLListDelFrm(&ranFuncDb->subscriptionList, ricSubsNode);
3737 deleteRicSubscriptionNode(ricSubsNode);
3742 case ProtocolIE_IDE2_id_CauseE2:
3744 /* No handling required as of now since this is a stub */
3754 /*******************************************************************
3756 * @brief Free RIC Subscription Modification Refuse
3760 * Function : FreeRicSubsModRefuse
3762 * Functionality: Free RIC Subscription Modification Refuse
3764 * @param E2AP Message PDU to be freed
3767 ******************************************************************/
3768 void FreeRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
3771 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
3775 if(e2apMsg->choice.unsuccessfulOutcome)
3777 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
3778 if(ricSubsModRefuse->protocolIEs.list.array)
3780 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
3782 RIC_FREE(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
3784 RIC_FREE(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
3786 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
3788 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3792 /*******************************************************************
3794 * @brief Build And Send RIC Subscription Modification Refuse
3798 * Function : BuildAndSendRicSubsModRefuse
3800 * Functionality: Build And Send RIC Subscription Modification Refuse
3803 * RIC Request ID of subscription
3807 * @return ROK - success
3810 ******************************************************************/
3811 uint8_t BuildAndSendRicSubsModRefuse(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, CauseE2_PR causeType, \
3814 uint8_t ieIdx = 0, elementCnt = 0;
3815 uint8_t ret = RFAILED;
3816 E2AP_PDU_t *e2apMsg = NULL;
3817 asn_enc_rval_t encRetVal;
3818 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
3819 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
3821 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Refuse\n");
3824 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3825 if(e2apMsg == NULLP)
3827 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3830 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3831 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
3832 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3834 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3838 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
3839 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3840 e2apMsg->choice.unsuccessfulOutcome->value.present = \
3841 UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse;
3842 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
3845 ricSubsModRefuse->protocolIEs.list.count = elementCnt;
3846 ricSubsModRefuse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRefuse_IEs_t *);
3847 RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
3848 if(!ricSubsModRefuse->protocolIEs.list.array)
3850 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3854 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
3856 RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
3857 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
3859 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3864 /* RIC Request ID */
3866 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3867 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RICrequestID;
3868 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3869 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RICrequestID;
3870 ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3871 ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3873 /* RAN Function ID */
3875 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3876 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3877 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3878 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RANfunctionID;
3879 ricSubsModRefuseIe->value.choice.RANfunctionID = ranFuncId;
3883 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3884 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_CauseE2;
3885 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3886 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_CauseE2;
3887 fillE2FailureCause(&ricSubsModRefuseIe->value.choice.CauseE2, causeType, cause);
3889 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3890 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3892 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3894 /* Check encode results */
3895 if(encRetVal.encoded == ENCODE_FAIL)
3897 DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification refuse (at %s)\n",\
3898 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3903 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification refuse\n");
3904 for(int i=0; i< encBufSize; i++)
3906 DU_LOG("%x",encBuf[i]);
3910 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
3912 DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Refused");
3919 FreeRicSubsModRefuse(e2apMsg);
3923 /*******************************************************************
3925 * @brief Free memory for RIC Subscription Modification Confirm
3929 * Function : FreeRicSubsModConfirm
3931 * Functionality: Free memory for RIC subscription modification
3934 * @param E2AP Message PDU to be freed
3937 ******************************************************************/
3938 void FreeRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
3940 uint8_t ieIdx = 0, arrIdx=0;
3941 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
3942 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
3943 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
3944 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
3945 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
3946 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
3950 if(e2apMsg->choice.successfulOutcome)
3952 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
3953 if(ricSubsModCfm->protocolIEs.list.array)
3955 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
3957 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
3959 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
3960 switch(ricSubsModCfmIe->id)
3962 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
3964 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
3965 if(modCfmList->list.array)
3967 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
3969 RIC_FREE(modCfmList->list.array[arrIdx], \
3970 sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
3972 RIC_FREE(modCfmList->list.array, modCfmList->list.size);
3977 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
3979 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
3980 if(modRefusedList->list.array)
3982 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
3984 RIC_FREE(modRefusedList->list.array[arrIdx], \
3985 sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
3987 RIC_FREE(modRefusedList->list.array, modRefusedList->list.size);
3992 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
3994 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
3995 if(rmvCfmList->list.array)
3997 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
3999 RIC_FREE(rmvCfmList->list.array[arrIdx], \
4000 sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
4002 RIC_FREE(rmvCfmList->list.array, rmvCfmList->list.size);
4007 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
4009 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
4010 if(rmvFailList->list.array)
4012 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
4014 RIC_ALLOC(rmvFailList->list.array[arrIdx], \
4015 sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
4017 RIC_FREE(rmvFailList->list.array, rmvFailList->list.size);
4026 RIC_FREE(ricSubsModCfmIe, sizeof(RICsubscriptionModificationConfirm_IEs_t));
4029 RIC_FREE(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
4031 RIC_FREE(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
4033 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4037 /*******************************************************************
4039 * @brief Fill the list of actions confirmed for modification
4043 * Function : fillActionModConfirmedList
4045 * Functionality: Fill the list of actions confirmed for modification
4047 * @param List to be filled
4049 * Source list of actions
4050 * @return ROK - success
4053 ******************************************************************/
4054 uint8_t fillActionModConfirmedList(RICactions_ConfirmedForModification_List_t *modCfmList, uint8_t numActions, \
4055 uint8_t *actionModifiedList)
4058 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
4060 modCfmList->list.count = numActions;
4061 modCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForModification_ItemIEs_t *);
4062 RIC_ALLOC(modCfmList->list.array, modCfmList->list.size);
4063 if(!modCfmList->list.array)
4065 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4069 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
4071 RIC_ALLOC(modCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
4072 if(!modCfmList->list.array[arrIdx])
4074 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4078 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
4079 modCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForModification_Item;
4080 modCfmListItem->criticality = CriticalityE2_ignore;
4081 modCfmListItem->value.present = \
4082 RICaction_ConfirmedForModification_ItemIEs__value_PR_RICaction_ConfirmedForModification_Item;
4083 modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID = actionModifiedList[arrIdx];
4089 /*******************************************************************
4091 * @brief Fill the list of actions refused to be modified
4095 * Function : fillActionModRefusedList
4097 * Functionality: Fill the list of actions refused to be modified
4099 * @param List to be filled
4101 * Source list of actions refused tobe modified
4102 * @return ROK - success
4105 ******************************************************************/
4106 uint8_t fillActionModRefusedList(RICactions_RefusedToBeModified_List_t *modRefusedList, uint8_t numActions, \
4107 ActionFailed *actionModFailedList)
4110 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
4112 modRefusedList->list.count = numActions;
4113 modRefusedList->list.size = numActions * sizeof(RICaction_RefusedToBeModified_ItemIEs_t *);
4114 RIC_ALLOC(modRefusedList->list.array, modRefusedList->list.size);
4115 if(!modRefusedList->list.array)
4117 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4121 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
4123 RIC_ALLOC(modRefusedList->list.array[arrIdx], sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
4124 if(!modRefusedList->list.array[arrIdx])
4126 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4130 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
4131 modRefusedListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeModified_Item;
4132 modRefusedListItem->criticality = CriticalityE2_ignore;
4133 modRefusedListItem->value.present = \
4134 RICaction_RefusedToBeModified_ItemIEs__value_PR_RICaction_RefusedToBeModified_Item;
4135 modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID = \
4136 actionModFailedList[arrIdx].actionId;
4137 fillE2FailureCause(&modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.cause, \
4138 actionModFailedList[arrIdx].failureType, actionModFailedList[arrIdx].cause);
4144 /*******************************************************************
4146 * @brief Fill the list of action confirmed for removal
4150 * Function : fillActionRemovalConfirmedList
4152 * Functionality: Fill the list of action confirmed for removal
4154 * @param List to be filled
4156 * Source list of actions removed
4157 * @return ROK - success
4160 ******************************************************************/
4161 uint8_t fillActionRemovalConfirmedList(RICactions_ConfirmedForRemoval_List_t *rmvCfmList, uint8_t numActions, \
4162 uint8_t *actionRemovedList)
4165 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
4167 rmvCfmList->list.count = numActions;
4168 rmvCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t *);
4169 RIC_ALLOC(rmvCfmList->list.array, rmvCfmList->list.size);
4170 if(!rmvCfmList->list.array)
4172 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4176 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
4178 RIC_ALLOC(rmvCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
4179 if(!rmvCfmList->list.array[arrIdx])
4181 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4185 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
4186 rmvCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForRemoval_Item;
4187 rmvCfmListItem->criticality = CriticalityE2_ignore;
4188 rmvCfmListItem->value.present = \
4189 RICaction_ConfirmedForRemoval_ItemIEs__value_PR_RICaction_ConfirmedForRemoval_Item;
4190 rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID = actionRemovedList[arrIdx];
4196 /*******************************************************************
4198 * @brief Fill the list of actions refused to be removed
4202 * Function : fillActionRemovalRefusedList
4204 * Functionality: Fill the list of actions refused to be removed
4206 * @param List to be filled
4208 * Source list of actions refused to be removed
4209 * @return ROK - success
4212 ******************************************************************/
4213 uint8_t fillActionRemovalRefusedList(RICactions_RefusedToBeRemoved_List_t *rmvFailList, \
4214 uint8_t numActions, ActionFailed *actionRmvlFailList)
4217 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
4219 rmvFailList->list.count = numActions;
4220 rmvFailList->list.size = numActions * sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t *);
4221 RIC_ALLOC(rmvFailList->list.array, rmvFailList->list.size);
4222 if(!rmvFailList->list.array)
4224 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4228 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
4230 RIC_ALLOC(rmvFailList->list.array[arrIdx], sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
4231 if(!rmvFailList->list.array[arrIdx])
4233 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4237 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
4238 rmvFailListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeRemoved_Item;
4239 rmvFailListItem->criticality = CriticalityE2_ignore;
4240 rmvFailListItem->value.present = \
4241 RICaction_RefusedToBeRemoved_ItemIEs__value_PR_RICaction_RefusedToBeRemoved_Item;
4242 rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID = actionRmvlFailList[arrIdx].actionId;
4243 fillE2FailureCause(&rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.cause, \
4244 actionRmvlFailList[arrIdx].failureType, actionRmvlFailList[arrIdx].cause);
4251 /*******************************************************************
4253 * @brief Build And Send RIC Subscription Modification Confirm
4257 * Function : BuildAndSendRicSubsModConfirm
4259 * Functionality: Build And Send RIC Subscription Modification Confirm
4262 * RIC Request ID of subscription
4264 * Temporary source action list
4265 * @return ROK - success
4268 ******************************************************************/
4269 uint8_t BuildAndSendRicSubsModConfirm(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, RicTmpActionList tmpActionList)
4271 uint8_t ieIdx = 0, elementCnt = 0;
4272 uint8_t ret = RFAILED;
4273 E2AP_PDU_t *e2apMsg = NULLP;
4274 asn_enc_rval_t encRetVal;
4275 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
4276 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
4278 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Confirm\n");
4281 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4282 if(e2apMsg == NULLP)
4284 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4288 /* Successful Outcome */
4289 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
4290 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
4291 if(e2apMsg->choice.successfulOutcome == NULLP)
4293 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4297 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
4298 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
4299 e2apMsg->choice.successfulOutcome->value.present = \
4300 SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm;
4301 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
4304 if(tmpActionList.numActionModified)
4306 if(tmpActionList.numActionModFailed)
4308 if(tmpActionList.numActionRemoved)
4310 if(tmpActionList.numActionRemovalFailed)
4313 ricSubsModCfm->protocolIEs.list.count = elementCnt;
4314 ricSubsModCfm->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationConfirm_IEs_t *);
4315 RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
4316 if(!ricSubsModCfm->protocolIEs.list.array)
4318 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4322 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
4324 RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationConfirm_IEs_t));
4325 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
4327 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
4332 /* RIC Request ID */
4334 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4335 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICrequestID;
4336 ricSubsModCfmIe->criticality = CriticalityE2_reject;
4337 ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RICrequestID;
4338 ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
4339 ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
4341 /* RAN Function ID */
4343 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4344 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RANfunctionID;
4345 ricSubsModCfmIe->criticality = CriticalityE2_reject;
4346 ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RANfunctionID;
4347 ricSubsModCfmIe->value.choice.RANfunctionID = ranFuncId;
4349 /* RIC Actions List confirmed for modification */
4350 if(tmpActionList.numActionModified)
4353 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4354 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List;
4355 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4356 ricSubsModCfmIe->value.present = \
4357 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForModification_List;
4358 if(fillActionModConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List, \
4359 tmpActionList.numActionModified, tmpActionList.actionModifiedList) != ROK)
4361 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Modification List", __func__);
4366 /* RIC Actions List refured to be modified */
4367 if(tmpActionList.numActionModFailed)
4370 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4371 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List;
4372 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4373 ricSubsModCfmIe->value.present = \
4374 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeModified_List;
4375 if(fillActionModRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List, \
4376 tmpActionList.numActionModFailed, tmpActionList.actionModFailedList) != ROK)
4378 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Refused to be Modified List", __func__);
4383 /* RIC Actions List confirmed for removal */
4384 if(tmpActionList.numActionRemoved)
4387 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4388 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List;
4389 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4390 ricSubsModCfmIe->value.present = \
4391 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForRemoval_List;
4392 if(fillActionRemovalConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List, \
4393 tmpActionList.numActionRemoved, tmpActionList.actionRemovedList) != ROK)
4395 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Removal List", __func__);
4400 /* RIC Actions List Refused to be removed */
4401 if(tmpActionList.numActionRemovalFailed)
4404 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
4405 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List;
4406 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
4407 ricSubsModCfmIe->value.present = \
4408 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeRemoved_List;
4409 if(fillActionRemovalRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List, \
4410 tmpActionList.numActionRemovalFailed, tmpActionList.actionRemovalFailedList) != ROK)
4412 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Failed to be Removed List", __func__);
4417 /* Print and encode E2AP Message PDU */
4418 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4419 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4421 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
4423 /* Check encode results */
4424 if(encRetVal.encoded == ENCODE_FAIL)
4426 DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification confirm (at %s)\n",\
4427 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4432 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification confirm\n");
4433 for(int i=0; i< encBufSize; i++)
4435 DU_LOG("%x",encBuf[i]);
4439 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
4441 DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Confirm");
4449 FreeRicSubsModConfirm(e2apMsg);
4453 /*******************************************************************
4455 * @brief Processing of RIC Subscription Modification Required
4459 * Function : ProcRicSubsModReqd
4461 * Functionality: Processing of RIC Subscription Modification Required
4462 * As of now, we do not identify any scenario where this message
4463 * shall be sent by DU. Hence, bare minimum handling has been
4467 * RIC Subscription Modification Required IEs
4468 * @return ROK-success
4471 ******************************************************************/
4472 uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t *ricSubsModReqd)
4474 uint8_t ieIdx = 0, actionIdx = 0, duIdx = 0;
4478 RicRequestId ricReqId;
4479 RanFunction *ranFuncDb = NULLP;
4480 RicSubscription *ricSubs = NULLP;
4481 CmLList *ricSubsNode = NULLP;
4482 ActionInfo *action = NULLP;
4483 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
4484 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
4485 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
4486 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULLP;
4487 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULLP;
4488 RicTmpActionList tmpActionList;
4490 memset(&ricReqId, 0, sizeof(RicRequestId));
4491 memset(&tmpActionList, 0, sizeof(RicTmpActionList));
4493 SEARCH_DU_DB(duIdx, duId, duDb);
4496 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
4500 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
4502 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
4503 switch(ricSubsModReqdIe->id)
4505 case ProtocolIE_IDE2_id_RICrequestID:
4507 ricReqId.requestorId = ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID;
4508 ricReqId.instanceId = ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID;
4511 case ProtocolIE_IDE2_id_RANfunctionID:
4513 ranFuncId = ricSubsModReqdIe->value.choice.RANfunctionID;
4514 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
4517 /* If RIC Subscription not found, send RIC Subscription modification refuse to DU */
4518 DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RIC Subscription not found");
4519 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
4520 CauseE2RICrequest_ran_function_id_invalid);
4524 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
4527 /* If RAN Function not found, send RIC Subscription modification refuse to DU */
4528 DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RAN Function ID [%d] not found",ranFuncId);
4529 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, \
4530 CauseE2_PR_ricRequest, CauseE2RICrequest_request_id_unknown);
4535 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
4537 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
4538 for(actionIdx = 0; actionIdx < actionToBeModList->list.count; actionIdx++)
4540 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[actionIdx];
4541 actionId = actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID;
4542 action = fetchActionInfoFromActionId(actionId, ricSubs);
4545 /* No modification required as of now, hence directly adding to the list */
4546 tmpActionList.actionModifiedList[tmpActionList.numActionModified++] = actionId;
4550 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].actionId = actionId;
4551 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].failureType = \
4552 CauseE2_PR_ricRequest;
4553 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].cause = \
4554 CauseE2RICrequest_action_not_supported;
4555 tmpActionList.numActionModFailed++;
4560 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
4562 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
4563 for(actionIdx = 0; actionIdx < actionToBeRmvList->list.count; actionIdx++)
4565 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[actionIdx];
4566 actionId = actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID;
4567 action = fetchActionInfoFromActionId(actionId, ricSubs);
4570 tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId;
4571 memset(action, 0, sizeof(ActionInfo));
4572 action->actionId = -1;
4573 ricSubs->numOfActions--;
4583 /* If none of the action modification/removal is supported,
4584 * send RIC Subscription Modification Refuse
4586 * send RIC Subscription Modification Confirm
4588 if(tmpActionList.numActionModified || tmpActionList.numActionRemoved)
4590 BuildAndSendRicSubsModConfirm(duId, ricReqId, ranFuncId, tmpActionList);
4594 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
4595 CauseE2RICrequest_action_not_supported);
4601 /*******************************************************************
4603 * @brief Free the ErrorIndication Message
4607 * Function : FreeRicIndication
4609 * Functionality: Free the ErrorIndication Message
4614 ******************************************************************/
4615 void FreeErrorIndication(E2AP_PDU_t *e2apMsg)
4618 ErrorIndicationE2_t *errorIndicationMsg= NULLP;
4620 if(e2apMsg != NULLP)
4622 if(e2apMsg->choice.initiatingMessage != NULLP)
4624 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
4625 if(errorIndicationMsg!= NULLP)
4627 if(errorIndicationMsg->protocolIEs.list.array != NULLP)
4629 for(arrIdx=0; arrIdx<errorIndicationMsg->protocolIEs.list.count; arrIdx++)
4631 RIC_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t));
4633 RIC_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size);
4636 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4638 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4643 /*******************************************************************
4645 * @brief Builds and Send the ErrorIndication Message
4649 * Function : BuildAndSendErrorIndication
4651 * Functionality:Fills the ErrorIndication Message
4659 * @return ROK - success
4662 ******************************************************************/
4664 uint8_t BuildAndSendErrorIndication(uint32_t duId, int8_t transId, RicRequestId requestId, uint16_t ranFuncId, uint8_t reason)
4666 uint8_t elementCnt =0, arrIdx=0, ret = RFAILED;
4667 E2AP_PDU_t *e2apMsg = NULLP;
4668 ErrorIndicationE2_t *errorIndicationMsg=NULLP;
4669 asn_enc_rval_t encRetVal; /* Encoder return value */
4673 DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
4675 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4676 if(e2apMsg == NULLP)
4678 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
4682 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4683 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4684 if(e2apMsg->choice.initiatingMessage == NULLP)
4686 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
4689 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
4690 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4691 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2;
4693 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
4695 /* Element count is 2 for TransactionID/RICrequestID and Cause.
4696 * If the RAN function id is present, the count will be increased.*/
4701 errorIndicationMsg->protocolIEs.list.count = elementCnt;
4702 errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*);
4704 /* Initialize the E2Setup members */
4705 RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
4706 if(errorIndicationMsg->protocolIEs.list.array == NULLP)
4708 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
4711 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
4713 RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
4714 if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
4716 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array Idx %d in %s at line %d",arrIdx,__func__, __LINE__);
4720 if(arrIdx < elementCnt)
4725 if(transId >=0 && transId<=255)
4728 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4729 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4730 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID;
4731 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4736 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID;
4737 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4738 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID;
4739 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId;
4740 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
4745 /* RAN Function ID */
4747 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID;
4748 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4749 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID;
4750 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId;
4755 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
4756 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
4757 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
4758 fillE2FailureCause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, CauseE2_PR_misc, reason);
4761 /* Prints the Msg formed */
4762 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4763 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4765 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4767 if(encRetVal.encoded == ENCODE_FAIL)
4769 DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
4770 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4775 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
4776 #ifdef DEBUG_ASN_PRINT
4777 for(int i=0; i< encBufSize; i++)
4779 printf("%x",encBuf[i]);
4784 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
4786 DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
4792 FreeErrorIndication(e2apMsg);
4796 /*******************************************************************
4798 * @brief Deallocate the memory allocated for ResetRequest msg
4802 * Function : FreeResetRequest
4805 * - freeing the memory allocated for ResetRequest
4807 * @params[in] E2AP_PDU_t *e2apMsg
4808 * @return ROK - success
4811 * ****************************************************************/
4812 void FreeResetRequest(E2AP_PDU_t *e2apMsg)
4815 ResetRequestE2_t *resetReq = NULLP;
4817 if(e2apMsg != NULLP)
4819 if(e2apMsg->choice.initiatingMessage != NULLP)
4821 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4822 if(resetReq->protocolIEs.list.array)
4824 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
4826 RIC_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4828 RIC_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4830 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4832 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4836 /*******************************************************************
4838 * @brief Build and send the reset request msg
4842 * Function : BuildAndSendResetRequest
4845 * - Buld and send the reset request msg to E2 node
4851 * @return ROK - success
4854 * ****************************************************************/
4855 uint8_t BuildAndSendResetRequest(DuDb *duDb, CauseE2_PR causePresent, uint8_t reason)
4857 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
4858 uint8_t ret = RFAILED;
4859 E2AP_PDU_t *e2apMsg = NULLP;
4860 ResetRequestE2_t *resetReq = NULLP;
4861 asn_enc_rval_t encRetVal; /* Encoder return value */
4863 DU_LOG("\nINFO --> E2AP : Building Reset Request\n");
4867 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4868 if(e2apMsg == NULLP)
4870 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for E2AP-PDU failed");
4874 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4875 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4876 if(e2apMsg->choice.initiatingMessage == NULLP)
4878 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for initiatingMessage");
4882 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
4883 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4884 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
4885 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4888 resetReq->protocolIEs.list.count = elementCnt;
4889 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
4891 RIC_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4892 if(!resetReq->protocolIEs.list.array)
4894 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
4895 Reset Request IE array");
4899 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
4901 RIC_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4902 if(!resetReq->protocolIEs.list.array[ieIdx])
4904 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
4905 Reset Request IE array element");
4910 /* In case of failure */
4911 if(ieIdx < elementCnt)
4915 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4916 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
4917 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
4918 transId = assignTransactionId(duDb);
4919 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
4922 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
4923 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
4924 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
4925 fillE2FailureCause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
4927 /* Prints the Msg formed */
4928 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4930 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4932 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4934 if(encRetVal.encoded == ENCODE_FAIL)
4936 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
4937 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4942 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
4943 #ifdef DEBUG_ASN_PRINT
4944 for(int i=0; i< encBufSize; i++)
4946 printf("%x",encBuf[i]);
4950 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
4952 DU_LOG("\nERROR --> E2AP : Sending reset request failed");
4961 /* Free all memory */
4962 FreeResetRequest(e2apMsg);
4966 /******************************************************************
4968 * @brief Delete Ric subscription node
4972 * Function : deleteRicSubscriptionNode
4974 * Functionality: Delete Ric subscription node
4976 * @params[in] Ric subscription info
4980 * ****************************************************************/
4981 void deleteRicSubscriptionNode(CmLList *subscriptionNode)
4983 uint8_t actionIdx=0;
4984 RicSubscription *ricSubscriptionInfo = NULLP;
4986 ricSubscriptionInfo = (RicSubscription*)subscriptionNode->node;
4988 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
4990 if(ricSubscriptionInfo->actionSequence[actionIdx].actionId > -1)
4992 memset(&ricSubscriptionInfo->actionSequence[actionIdx], 0, sizeof(ActionInfo));
4995 memset(ricSubscriptionInfo, 0, sizeof(RicSubscription));
4996 RIC_FREE(subscriptionNode->node, sizeof(RicSubscription));
4997 RIC_FREE(subscriptionNode, sizeof(CmLList));
5000 /*******************************************************************
5002 * @brief Delete RIC subscription List
5006 * Function : deleteRicSubscriptionList
5008 * Functionality: Delete RIC subscription list
5010 * @params[in] RIC Subscription list
5014 ******************************************************************/
5015 void deleteRicSubscriptionList(CmLListCp *subscriptionList)
5017 CmLList *subscriptionNode = NULLP;
5019 CM_LLIST_FIRST_NODE(subscriptionList, subscriptionNode);
5020 while(subscriptionNode)
5022 cmLListDelFrm(subscriptionList, subscriptionNode);
5023 deleteRicSubscriptionNode(subscriptionNode);
5024 CM_LLIST_FIRST_NODE(subscriptionList, subscriptionNode);
5028 /*******************************************************************
5030 * @brief process the E2 Reset Response
5034 * Function : ProcResetResponse
5036 * Functionality: Process E2 Reset Response
5040 * Pointer to reset response
5043 ******************************************************************/
5045 void ProcResetResponse(uint32_t duId, ResetResponseE2_t *resetRsp)
5047 uint8_t ieIdx = 0, duIdx =0;
5049 RanFunction *ranFuncDb = NULLP;
5050 uint16_t ranFuncIdx = 0;
5052 SEARCH_DU_DB(duIdx, duId, duDb);
5055 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5061 DU_LOG("\nERROR --> E2AP : resetRsp pointer is null");
5065 if(!resetRsp->protocolIEs.list.array)
5067 DU_LOG("\nERROR --> E2AP : resetRsp array pointer is null");
5071 for(ieIdx=0; ieIdx < resetRsp->protocolIEs.list.count; ieIdx++)
5073 if(resetRsp->protocolIEs.list.array[ieIdx])
5075 switch(resetRsp->protocolIEs.list.array[ieIdx]->id)
5077 case ProtocolIE_IDE2_id_TransactionID:
5079 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
5081 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
5082 if(ranFuncDb->id > 0)
5084 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
5089 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
5099 /*******************************************************************
5101 * @brief process the E2 Reset Request
5105 * Function : ProcResetRequest
5107 * Functionality: Process E2 Reset Request
5111 * Pointer to reset response
5114 ******************************************************************/
5116 void ProcResetRequest(uint32_t duId, ResetRequestE2_t *resetReq)
5118 uint8_t ieIdx = 0, duIdx =0, transId=0;
5120 RanFunction *ranFuncDb = NULLP;
5121 uint16_t ranFuncIdx = 0;
5123 SEARCH_DU_DB(duIdx, duId, duDb);
5126 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5132 DU_LOG("\nERROR --> E2AP : resetReq pointer is null");
5136 if(!resetReq->protocolIEs.list.array)
5138 DU_LOG("\nERROR --> E2AP : resetReq array pointer is null");
5142 for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
5144 if(resetReq->protocolIEs.list.array[ieIdx])
5146 switch(resetReq->protocolIEs.list.array[ieIdx]->id)
5148 case ProtocolIE_IDE2_id_TransactionID:
5150 transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5153 case ProtocolIE_IDE2_id_CauseE2:
5155 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
5157 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
5158 if(ranFuncDb->id > 0)
5160 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
5169 if(BuildAndSendResetResponse(duId, transId) !=ROK)
5171 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
5175 /*******************************************************************
5177 * @brief Free RIC Subscription Delete Request Message
5181 * Function : FreeRicSubscriptionDeleteRequest
5183 * Functionality: Free RIC Subscription Delete Request
5185 * @param E2AP Message PDU
5188 ******************************************************************/
5189 void FreeRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
5191 uint8_t ieIdx = 0, arrIdx = 0;
5192 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
5196 if(e2apMsg->choice.initiatingMessage)
5198 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
5199 if(ricSubsDelReq->protocolIEs.list.array)
5201 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
5203 RIC_FREE(ricSubsDelReq->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
5205 RIC_FREE(ricSubsDelReq->protocolIEs.list.array, ricSubsDelReq->protocolIEs.list.size);
5207 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5209 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
5213 /*******************************************************************
5215 * @brief Builds and Send RIC Subscription delete request
5219 * Function : BuildAndSendRicSubscriptionDeleteRequest
5221 * Functionality: Build and send RIC subscription delete request.
5224 * RIC subscription info to be deleted
5225 * @return ROK - success
5228 ******************************************************************/
5229 uint8_t BuildAndSendRicSubscriptionDeleteRequest(uint32_t duId, RicSubscription *ricSubsDb)
5231 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
5232 E2AP_PDU_t *e2apMsg = NULLP;
5233 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
5234 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
5235 asn_enc_rval_t encRetVal; /* Encoder return value */
5239 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Request Message\n");
5241 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5242 if(e2apMsg == NULLP)
5244 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
5248 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5249 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5250 if(e2apMsg->choice.initiatingMessage == NULLP)
5252 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
5255 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDelete;
5256 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5257 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest;
5259 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
5262 ricSubsDelReq->protocolIEs.list.count = elementCnt;
5263 ricSubsDelReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequest_IEs_t *);
5265 RIC_ALLOC(ricSubsDelReq->protocolIEs.list.array, ricSubsDelReq->protocolIEs.list.size);
5266 if(ricSubsDelReq->protocolIEs.list.array == NULLP)
5268 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
5272 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5274 RIC_ALLOC(ricSubsDelReq->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequest_IEs_t));
5275 if(ricSubsDelReq->protocolIEs.list.array[ieIdx] == NULLP)
5277 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
5278 __func__, ieIdx, __LINE__);
5282 if(ieIdx < elementCnt)
5285 /* RIC Request ID */
5287 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
5288 ricSubsDelReqIe->id = ProtocolIE_IDE2_id_RICrequestID;
5289 ricSubsDelReqIe->criticality = CriticalityE2_reject;
5290 ricSubsDelReqIe->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RICrequestID;
5291 ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID = ricSubsDb->requestId.requestorId;
5292 ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID = ricSubsDb->requestId.instanceId;
5294 /* RAN Function ID */
5296 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
5297 ricSubsDelReqIe->id = ProtocolIE_IDE2_id_RANfunctionID;
5298 ricSubsDelReqIe->criticality = CriticalityE2_reject;
5299 ricSubsDelReqIe->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RANfunctionID;
5300 ricSubsDelReqIe->value.choice.RANfunctionID = ricSubsDb->ranFuncId;
5302 /* Prints the Msg formed */
5303 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5304 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5306 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5307 if(encRetVal.encoded == ENCODE_FAIL)
5309 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Request Message (at %s)\n",\
5310 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5315 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Request Message \n");
5316 #ifdef DEBUG_ASN_PRINT
5317 for(int i=0; i< encBufSize; i++)
5319 printf("%x",encBuf[i]);
5324 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
5326 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Request Message");
5334 FreeRicSubscriptionDeleteRequest(e2apMsg);
5338 /*******************************************************************
5340 * @brief Processing of RIC Subscription Delete Required
5344 * Function : ProcRicSubsDeleteReqd
5346 * Functionality: Processing of RIC Subscription Delete Required
5347 * When received, RIC stub will initiate the RIC subscription
5348 * deletion procedure towards DU
5351 * RIC Subscription Delete Required IEs
5352 * @return ROK-success
5355 ******************************************************************/
5356 uint8_t ProcRicSubsDeleteReqd(uint32_t duId, RICsubscriptionDeleteRequired_t *ricSubsDelRqd)
5358 uint8_t ieIdx = 0, duIdx = 0;
5359 uint16_t arrIdx = 0;
5361 RicRequestId ricReqId;
5362 RanFunction *ranFuncDb = NULLP;
5363 RicSubscription *subsDb = NULLP;
5364 CmLList *ricSubsNode = NULLP;
5366 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
5367 RICsubscription_List_withCause_t *ricSubsList = NULLP;
5368 RICsubscription_withCause_Item_t *subsItem = NULLP;
5370 memset(&ricReqId, 0, sizeof(RicRequestId));
5374 DU_LOG("\nERROR --> E2AP : %s: Received NULL message", __func__);
5378 SEARCH_DU_DB(duIdx, duId, duDb);
5381 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
5385 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
5387 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
5388 switch(ricSubsDelRqdIe->id)
5390 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
5392 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
5393 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
5395 subsItem = &(((RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[arrIdx])->\
5396 value.choice.RICsubscription_withCause_Item);
5397 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, subsItem->ranFunctionID);
5400 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%ld] not found", __func__, subsItem->ranFunctionID);
5404 ricReqId.requestorId = subsItem->ricRequestID.ricRequestorID;
5405 ricReqId.instanceId = subsItem->ricRequestID.ricInstanceID;
5406 subsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
5409 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%ld] Instance_ID [%ld]", \
5410 __func__, subsItem->ricRequestID.ricRequestorID, subsItem->ricRequestID.ricInstanceID);
5414 /* Delete RIC Subcription from RAN Function */
5415 cmLListDelFrm(&ranFuncDb->subscriptionList, ricSubsNode);
5417 /* Send RIC Subscription delete request and then free any memory
5418 * allocated to store subscription info at RIC */
5419 BuildAndSendRicSubscriptionDeleteRequest(duId, (RicSubscription *)ricSubsNode->node);
5420 deleteRicSubscriptionNode(ricSubsNode);
5433 /*******************************************************************
5435 * @brief Deallocate memory allocated for E2nodeConfigurationUpdate
5439 * Function : freeE2NodeConfigItem
5442 * - freeing the memory allocated for E2nodeConfigurationUpdate
5445 * uint8_t protocolIe
5446 * PTR to e2NodeCfg which is to be freed
5447 * @return ROK - success
5450 * ****************************************************************/
5452 void freeE2NodeConfigItem(uint8_t protocolIe, PTR e2NodeCfg)
5454 E2nodeComponentConfigurationAck_t *cfgAck =NULLP;
5455 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULLP;
5456 E2nodeComponentConfigAdditionAck_Item_t *e2NodeAdditionAckItemIe=NULLP;
5457 E2nodeComponentConfigRemovalAck_Item_t *e2NodeRemovalAckItemIe=NULLP;
5458 E2nodeComponentConfigUpdateAck_Item_t *e2NodeUpdateAckItemIe=NULLP;
5460 /* Extracting the component interface and configuration ack information from
5461 * e2NodeCfg based on the protocol id */
5464 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
5466 e2NodeAdditionAckItemIe= (E2nodeComponentConfigAdditionAck_Item_t*)e2NodeCfg;
5467 switch(e2NodeAdditionAckItemIe->e2nodeComponentInterfaceType)
5469 case E2nodeComponentInterfaceType_f1:
5471 f1InterfaceInfo = e2NodeAdditionAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5480 cfgAck = &e2NodeAdditionAckItemIe->e2nodeComponentConfigurationAck;
5483 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
5485 e2NodeUpdateAckItemIe = (E2nodeComponentConfigUpdateAck_Item_t*)e2NodeCfg;
5486 switch(e2NodeUpdateAckItemIe->e2nodeComponentInterfaceType)
5488 case E2nodeComponentInterfaceType_f1:
5490 f1InterfaceInfo = e2NodeUpdateAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5498 cfgAck = &e2NodeUpdateAckItemIe->e2nodeComponentConfigurationAck;
5501 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
5503 e2NodeRemovalAckItemIe= (E2nodeComponentConfigRemovalAck_Item_t*)e2NodeCfg;
5504 switch(e2NodeRemovalAckItemIe->e2nodeComponentInterfaceType)
5506 case E2nodeComponentInterfaceType_f1:
5508 f1InterfaceInfo = e2NodeRemovalAckItemIe->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
5516 cfgAck = &e2NodeRemovalAckItemIe->e2nodeComponentConfigurationAck;
5520 /* Freeing the memory allocated to component interface and configuration ack */
5523 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
5524 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
5527 switch(cfgAck->updateOutcome)
5529 case E2nodeComponentConfigurationAck__updateOutcome_success:
5531 case E2nodeComponentConfigurationAck__updateOutcome_failure:
5533 RIC_FREE(cfgAck->failureCauseE2, sizeof(CauseE2_t));
5540 /*******************************************************************
5542 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
5546 * Function : FreeE2NodeConfigUpdate
5549 * - freeing the memory allocated for E2nodeConfigurationUpdate
5551 * @params[in] E2AP_PDU_t *e2apMsg
5552 * @return ROK - success
5555 * ****************************************************************/
5557 void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
5559 uint8_t arrIdx =0, e2NodeConfigIdx=0;
5560 E2nodeConfigurationUpdateAcknowledge_t *updateAckMsg=NULL;
5561 E2nodeComponentConfigUpdateAck_ItemIEs_t *updateAckItemIe=NULL;
5562 E2nodeComponentConfigUpdateAck_List_t *updateAckList=NULL;
5563 E2nodeComponentConfigRemovalAck_ItemIEs_t *removalAckItemIe=NULL;
5564 E2nodeComponentConfigRemovalAck_List_t *removalAckList=NULL;
5565 E2nodeComponentConfigAdditionAck_ItemIEs_t *additionAckItemIte=NULL;
5566 E2nodeComponentConfigAdditionAck_List_t *additionAckList=NULL;
5568 if(e2apMsg != NULLP)
5570 if(e2apMsg->choice.successfulOutcome != NULLP)
5572 updateAckMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
5573 if(updateAckMsg->protocolIEs.list.array != NULLP)
5575 for(arrIdx = 0; arrIdx < updateAckMsg->protocolIEs.list.count; arrIdx++)
5577 if(updateAckMsg->protocolIEs.list.array[arrIdx])
5579 switch(updateAckMsg->protocolIEs.list.array[arrIdx]->id)
5581 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
5583 additionAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
5584 if(additionAckList->list.array)
5586 for(e2NodeConfigIdx=0; e2NodeConfigIdx<additionAckList->list.count; e2NodeConfigIdx++)
5588 additionAckItemIte = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) additionAckList->list.array[e2NodeConfigIdx];
5589 if(additionAckItemIte)
5591 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck,\
5592 (PTR)&additionAckItemIte->value.choice.E2nodeComponentConfigAdditionAck_Item);
5593 RIC_FREE(additionAckItemIte, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
5596 RIC_FREE(additionAckList->list.array, additionAckList->list.size);
5600 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck:
5602 updateAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List;
5603 if(updateAckList->list.array)
5605 for(e2NodeConfigIdx=0; e2NodeConfigIdx<updateAckList->list.count; e2NodeConfigIdx++)
5607 updateAckItemIe = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) updateAckList->list.array[e2NodeConfigIdx];
5610 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck,\
5611 (PTR)&updateAckItemIe->value.choice.E2nodeComponentConfigUpdateAck_Item);
5612 RIC_FREE(updateAckItemIe, sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t));
5615 RIC_FREE(updateAckList->list.array, updateAckList->list.size);
5619 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck:
5621 removalAckList =&updateAckMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List;
5622 if(removalAckList->list.array)
5624 for(e2NodeConfigIdx=0; e2NodeConfigIdx<removalAckList->list.count; e2NodeConfigIdx++)
5626 removalAckItemIe = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) removalAckList->list.array[e2NodeConfigIdx];
5627 if(removalAckItemIe)
5629 freeE2NodeConfigItem(ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck,\
5630 (PTR)&removalAckItemIe->value.choice.E2nodeComponentConfigRemovalAck_Item);
5631 RIC_FREE(removalAckItemIe, sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t));
5634 RIC_FREE(removalAckList->list.array, removalAckList->list.size);
5639 RIC_FREE(updateAckMsg->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
5642 RIC_FREE(updateAckMsg->protocolIEs.list.array, updateAckMsg->protocolIEs.list.size);
5644 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
5646 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5650 /*******************************************************************
5652 * @brief Build E2node Component config Removal ack list
5656 * Function : BuildE2nodeComponentConfigRemovalAck
5658 * Functionality: Build the e2 node remove ack
5661 * E2nodeComponentConfigRemovalAck_List_t to be filled
5662 * Count of e2 node to be removed
5663 * list of e2 node cfg to be removed
5665 * @return ROK - success
5667 * ****************************************************************/
5669 uint8_t BuildE2nodeComponentConfigRemovalAck(E2nodeComponentConfigRemovalAck_List_t *e2NodeConfigRemovalAckList,\
5670 uint16_t removalE2NodeCount, E2NodeConfigItem *removaldE2Node)
5673 E2nodeComponentConfigRemovalAck_ItemIEs_t *e2NodeRemovalAckItem=NULL;
5675 /* Filling the e2 node config removal ack list */
5676 e2NodeConfigRemovalAckList->list.count = removalE2NodeCount;
5677 e2NodeConfigRemovalAckList->list.size = e2NodeConfigRemovalAckList->list.count * sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t*);
5678 RIC_ALLOC(e2NodeConfigRemovalAckList->list.array, e2NodeConfigRemovalAckList->list.size);
5679 if(e2NodeConfigRemovalAckList->list.array == NULLP)
5681 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
5685 for(arrIdx = 0; arrIdx< e2NodeConfigRemovalAckList->list.count; arrIdx++)
5687 RIC_ALLOC(e2NodeConfigRemovalAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemovalAck_ItemIEs_t));
5688 if(e2NodeConfigRemovalAckList->list.array[arrIdx] == NULLP)
5690 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigRemovalAck %d",__LINE__);
5693 e2NodeRemovalAckItem = (E2nodeComponentConfigRemovalAck_ItemIEs_t*) e2NodeConfigRemovalAckList->list.array[arrIdx];
5694 e2NodeRemovalAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck_Item;
5695 e2NodeRemovalAckItem->criticality = CriticalityE2_reject;
5696 e2NodeRemovalAckItem->value.present = E2nodeComponentConfigRemovalAck_ItemIEs__value_PR_E2nodeComponentConfigRemovalAck_Item;
5698 /* Filling the e2 node config removal ack item */
5699 fillE2NodeConfigAck((PTR)&e2NodeRemovalAckItem->value.choice.E2nodeComponentConfigRemovalAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck,\
5700 &removaldE2Node[arrIdx].componentInfo, removaldE2Node[arrIdx].isSuccessful);
5705 /*******************************************************************
5707 * @brief Build E2node Component config update ack list
5711 * Function : BuildE2nodeComponentConfigUpdateAck
5713 * Functionality: Build E2node Component config update ack list
5716 * E2nodeComponentConfigUpdateAck_List to be filled
5717 * Count of e2 node to be update
5718 * list of e2 node cfg to be update
5720 * @return ROK - success
5722 * ****************************************************************/
5724 uint8_t BuildE2nodeComponentConfigUpdateAck(E2nodeComponentConfigUpdateAck_List_t *e2NodeConfigUpdateAckList,\
5725 uint16_t updatedE2NodeCount, E2NodeConfigItem *updatedE2Node)
5728 E2nodeComponentConfigUpdateAck_ItemIEs_t *e2NodeUpdateAckItem=NULL;
5730 /* Filling the e2 node config update ack list */
5731 e2NodeConfigUpdateAckList->list.count = updatedE2NodeCount;
5732 e2NodeConfigUpdateAckList->list.size = e2NodeConfigUpdateAckList->list.count * sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t*);
5733 RIC_ALLOC(e2NodeConfigUpdateAckList->list.array, e2NodeConfigUpdateAckList->list.size);
5734 if(e2NodeConfigUpdateAckList->list.array == NULLP)
5736 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
5740 for(arrIdx = 0; arrIdx< e2NodeConfigUpdateAckList->list.count; arrIdx++)
5742 RIC_ALLOC(e2NodeConfigUpdateAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdateAck_ItemIEs_t));
5743 if(e2NodeConfigUpdateAckList->list.array[arrIdx] == NULLP)
5745 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigUpdateAck %d",__LINE__);
5748 e2NodeUpdateAckItem = (E2nodeComponentConfigUpdateAck_ItemIEs_t*) e2NodeConfigUpdateAckList->list.array[arrIdx];
5749 e2NodeUpdateAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck_Item;
5750 e2NodeUpdateAckItem->criticality = CriticalityE2_reject;
5751 e2NodeUpdateAckItem->value.present = E2nodeComponentConfigUpdateAck_ItemIEs__value_PR_E2nodeComponentConfigUpdateAck_Item;
5753 /* Filling the e2 node config update ack item */
5754 fillE2NodeConfigAck((PTR)&e2NodeUpdateAckItem->value.choice.E2nodeComponentConfigUpdateAck_Item, ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck,\
5755 &updatedE2Node[arrIdx].componentInfo, updatedE2Node[arrIdx].isSuccessful);
5761 /*******************************************************************
5763 * @brief Buld and send the E2 node config update ack msg
5767 * Function : BuildAndSendE2NodeConfigUpdateAck
5770 * - Buld and send the E2 node config update ack msg
5774 * list of E2 node cfg which needs to fill in IEs
5775 * @return ROK - success
5778 * ****************************************************************/
5780 uint8_t BuildAndSendE2NodeConfigUpdateAck(DuDb *duDb, uint8_t transId, E2NodeConfigList *e2NodeList)
5782 uint8_t ret = RFAILED;
5783 uint8_t arrIdx = 0,elementCnt = 0;
5784 E2AP_PDU_t *e2apMsg = NULLP;
5785 asn_enc_rval_t encRetVal;
5786 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
5788 DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
5791 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5792 if(e2apMsg == NULLP)
5794 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5797 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
5798 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
5799 if(e2apMsg->choice.successfulOutcome == NULLP)
5801 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5805 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
5806 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
5807 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
5808 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
5811 if(e2NodeList->addedE2NodeCount)
5813 if(e2NodeList->updatedE2NodeCount)
5815 if(e2NodeList->removedE2NodeCount)
5818 e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
5819 e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
5820 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
5821 if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
5823 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5827 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
5829 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
5830 if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
5833 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__,__LINE__);
5838 if(arrIdx<elementCnt)
5842 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5843 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5844 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
5845 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5847 if(e2NodeList->addedE2NodeCount)
5850 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
5851 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5852 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigAdditionAck_List;
5853 if(BuildE2nodeComponentConfigAdditionAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List,\
5854 e2NodeList->addedE2NodeCount, e2NodeList->addedE2Node)!=ROK)
5857 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
5861 if(e2NodeList->updatedE2NodeCount)
5864 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdateAck;
5865 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5866 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigUpdateAck_List;
5867 if(BuildE2nodeComponentConfigUpdateAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdateAck_List,\
5868 e2NodeList->updatedE2NodeCount, e2NodeList->updatedE2Node)!=ROK)
5871 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config update ack list");
5875 if(e2NodeList->removedE2NodeCount)
5878 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemovalAck;
5879 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5880 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_E2nodeComponentConfigRemovalAck_List;
5881 if(BuildE2nodeComponentConfigRemovalAck(&e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemovalAck_List,\
5882 e2NodeList->removedE2NodeCount, e2NodeList->removedE2Node)!=ROK)
5885 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config removal ack list");
5889 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5891 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5893 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
5895 if(encRetVal.encoded == ENCODE_FAIL)
5897 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
5898 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5903 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
5904 for(int i=0; i< encBufSize; i++)
5906 DU_LOG("%x",encBuf[i]);
5912 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
5914 DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
5921 FreeE2NodeConfigUpdateAck(e2apMsg);
5926 /******************************************************************
5928 * @brief Processes the E2 removal failure msg
5932 * Function : procE2RemovalFailure
5934 * Functionality: Processes the E2 removal failure msg
5937 * E2 Removal Failure information
5941 * ****************************************************************/
5942 void ProcE2RemovalFailure(E2RemovalFailure_t *e2RemovalFailure)
5944 uint8_t ieIdx = 0, transId=0;
5945 CauseE2_t *cause = NULLP;
5947 if(!e2RemovalFailure)
5949 DU_LOG("\nERROR --> E2AP : e2RemovalFailure pointer is null");
5953 if(!e2RemovalFailure->protocolIEs.list.array)
5955 DU_LOG("\nERROR --> E2AP : e2RemovalFailure array pointer is null");
5959 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
5961 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
5963 switch(e2RemovalFailure->protocolIEs.list.array[ieIdx]->id)
5965 case ProtocolIE_IDE2_id_TransactionID:
5967 transId = e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
5968 DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
5971 case ProtocolIE_IDE2_id_CauseE2:
5973 cause = &e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
5974 printE2ErrorCause(cause);
5979 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%d]", e2RemovalFailure->protocolIEs.list.array[ieIdx]->id);
5986 /*******************************************************************
5988 * @brief Delete E2 component node list
5992 * Function : deleteE2ComponentNodeList
5994 * Functionality: Delete E2 component node list
5996 * @params[in] E2 component node list
6000 ******************************************************************/
6002 void deleteE2ComponentNodeList(CmLListCp *componentList)
6004 E2NodeComponent *cfgInfo = NULLP;
6005 CmLList *e2ComponentNode = NULLP;
6007 CM_LLIST_FIRST_NODE(componentList, e2ComponentNode);
6008 while(e2ComponentNode)
6010 cfgInfo = (E2NodeComponent*)e2ComponentNode->node;
6011 cmLListDelFrm(componentList, e2ComponentNode);
6012 memset(cfgInfo, 0, sizeof(E2NodeComponent));
6013 CM_LLIST_FIRST_NODE(componentList, e2ComponentNode);
6017 /*******************************************************************
6019 * @brief process the E2 node information from ric db
6023 * Function : deleteE2NodeInfo
6025 * Functionality: process the E2 node information from ric db
6032 ******************************************************************/
6033 void deleteE2NodeInfo(DuDb *duDb)
6035 uint16_t ranFuncIdx =0;
6036 RanFunction *ranFuncDb=NULLP;
6038 DU_LOG("\nINFO --> E2AP : Removing all the E2 node information");
6039 for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
6041 ranFuncDb = &duDb->ranFunction[ranFuncIdx];
6042 if(ranFuncDb->id > 0)
6044 deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
6047 deleteE2ComponentNodeList(&duDb->e2NodeComponent);
6050 /*******************************************************************
6052 * @brief process the E2 Removal Response
6056 * Function : ProcE2RemovalResponse
6058 * Functionality: Process E2 Removal Response
6062 * Pointer to removal response
6065 ******************************************************************/
6067 void ProcE2RemovalResponse(uint32_t duId, E2RemovalResponse_t *removalRsp)
6069 uint8_t ieIdx = 0, duIdx =0;
6072 SEARCH_DU_DB(duIdx, duId, duDb);
6075 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6081 DU_LOG("\nERROR --> E2AP : removalRsp pointer is null");
6085 if(!removalRsp->protocolIEs.list.array)
6087 DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
6091 for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
6093 if(removalRsp->protocolIEs.list.array[ieIdx])
6095 switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
6097 case ProtocolIE_IDE2_id_TransactionID:
6099 DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
6100 cmInetClose(&sctpCb.e2LstnSockFd);
6101 deleteE2NodeInfo(duDb);
6106 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
6113 /*******************************************************************
6115 * @brief Deallocate the memory allocated for E2 Removal Failure
6119 * Function : FreeE2RemovalFailure
6122 * - freeing the memory allocated for E2RemovalFailure
6124 * @params[in] E2AP_PDU_t *e2apMsg
6127 * ****************************************************************/
6128 void FreeE2RemovalFailure(E2AP_PDU_t *e2apMsg)
6131 E2RemovalFailure_t *e2RemovalFailure=NULLP;
6133 if(e2apMsg != NULLP)
6135 if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
6137 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
6138 if(e2RemovalFailure->protocolIEs.list.array)
6140 for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
6142 if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
6144 RIC_FREE(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
6147 RIC_FREE(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
6149 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
6151 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6155 /*******************************************************************
6157 * @brief Buld and send the E2 Removal Failure msg
6161 * Function : BuildAndSendE2RemovalFailure
6164 * - Buld and send the E2 Removal Failure Message
6170 * @return ROK - success
6173 * ****************************************************************/
6175 uint8_t BuildAndSendRemovalFailure(uint32_t duId, uint16_t transId, CauseE2_PR causePresent, uint8_t reason)
6177 uint8_t ieIdx = 0, elementCnt = 0;
6178 uint8_t ret = RFAILED;
6179 E2AP_PDU_t *e2apMsg = NULLP;
6180 E2RemovalFailure_t *e2RemovalFailure=NULLP;
6181 asn_enc_rval_t encRetVal; /* Encoder return value */
6183 DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
6186 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6187 if(e2apMsg == NULLP)
6189 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6192 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
6194 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
6195 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
6197 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6201 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
6202 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
6203 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure;
6204 e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
6207 e2RemovalFailure->protocolIEs.list.count = elementCnt;
6208 e2RemovalFailure->protocolIEs.list.size = elementCnt * sizeof(E2RemovalFailureIEs_t *);
6209 RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
6210 if(!e2RemovalFailure->protocolIEs.list.array)
6212 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6216 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6218 RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
6219 if(!e2RemovalFailure->protocolIEs.list.array[ieIdx])
6221 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6225 if(ieIdx < elementCnt)
6229 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6230 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6231 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = E2RemovalFailureIEs__value_PR_TransactionID;
6232 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
6236 e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
6237 e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
6238 e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
6239 fillE2FailureCause(&e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
6241 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6243 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6245 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6246 if(encRetVal.encoded == ENCODE_FAIL)
6248 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal failure structure (at %s)\n",\
6249 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6254 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Failure \n");
6255 for(int i=0; i< encBufSize; i++)
6257 DU_LOG("%x",encBuf[i]);
6262 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6264 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Failure");
6272 FreeE2RemovalFailure(e2apMsg);
6276 /*******************************************************************
6278 * @brief Deallocate the memory allocated for E2 Removal Response
6282 * Function : FreeE2RemovalResponse
6285 * - freeing the memory allocated for E2RemovalResponse
6287 * @params[in] E2AP_PDU_t *e2apMsg
6288 * @return ROK - success
6291 * ****************************************************************/
6292 void FreeE2RemovalResponse(E2AP_PDU_t *e2apMsg)
6295 E2RemovalResponse_t *e2RemovalResponse=NULLP;
6297 if(e2apMsg != NULLP)
6299 if(e2apMsg->choice.successfulOutcome != NULLP)
6301 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
6302 if(e2RemovalResponse->protocolIEs.list.array)
6304 for(ieIdx=0; ieIdx < e2RemovalResponse->protocolIEs.list.count; ieIdx++)
6306 if(e2RemovalResponse->protocolIEs.list.array[ieIdx])
6308 RIC_FREE(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
6311 RIC_FREE(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
6313 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6315 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6319 /*******************************************************************
6321 * @brief Buld and send the E2 Removal Response msg
6325 * Function : BuildAndSendE2RemovalResponse
6328 * - Buld and send the E2 Removal Response Message
6332 * @return ROK - success
6335 * ****************************************************************/
6336 uint8_t BuildAndSendRemovalResponse(uint32_t duId, uint16_t transId)
6338 uint8_t ieIdx = 0, elementCnt = 0;
6339 uint8_t ret = RFAILED, duIdx =0;
6340 E2AP_PDU_t *e2apMsg = NULLP;
6342 E2RemovalResponse_t *e2RemovalResponse=NULLP;
6343 asn_enc_rval_t encRetVal; /* Encoder return value */
6345 DU_LOG("\nINFO --> E2AP : Building E2 Removal Response Message\n");
6348 SEARCH_DU_DB(duIdx, duId, duDb);
6351 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6355 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6356 if(e2apMsg == NULLP)
6358 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6361 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
6363 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6364 if(e2apMsg->choice.successfulOutcome == NULLP)
6366 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6370 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
6371 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
6372 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2RemovalResponse;
6373 e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
6376 e2RemovalResponse->protocolIEs.list.count = elementCnt;
6377 e2RemovalResponse->protocolIEs.list.size = elementCnt * sizeof(E2RemovalResponseIEs_t *);
6378 RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
6379 if(!e2RemovalResponse->protocolIEs.list.array)
6381 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6385 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6387 RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
6388 if(!e2RemovalResponse->protocolIEs.list.array[ieIdx])
6390 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6394 if(ieIdx < elementCnt)
6398 e2RemovalResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6399 e2RemovalResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6400 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.present = E2RemovalResponseIEs__value_PR_TransactionID;
6401 e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
6403 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6405 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6407 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6408 if(encRetVal.encoded == ENCODE_FAIL)
6410 DU_LOG("\nERROR --> E2AP : Could not encode E2 removal response structure (at %s)\n",\
6411 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6416 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \n");
6417 for(int i=0; i< encBufSize; i++)
6419 DU_LOG("%x",encBuf[i]);
6424 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6426 DU_LOG("\nERROR --> E2AP : Failed to send E2 Removal Response");
6434 FreeE2RemovalResponse(e2apMsg);
6438 /*******************************************************************
6440 * @brief Process Removal req received from RIC
6444 * Function : procE2RemovalRequest
6446 * Functionality: Process Removal req received from RIC
6450 * E2 Removal Request
6453 ******************************************************************/
6455 void procE2RemovalRequest(uint32_t duId, E2RemovalRequest_t *removalReq)
6458 uint16_t transId =0;
6460 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
6462 for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
6464 switch(removalReq->protocolIEs.list.array[arrIdx]->id)
6466 case ProtocolIE_IDE2_id_TransactionID:
6468 transId = removalReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
6473 DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
6479 if(transId>=0 && transId<=255)
6481 if(BuildAndSendRemovalResponse(duId, transId) != ROK)
6483 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
6488 if(BuildAndSendRemovalFailure(duId, transId, CauseE2_PR_protocol, CauseE2Protocol_abstract_syntax_error_falsely_constructed_message) != ROK)
6490 DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
6495 /*******************************************************************
6497 * @brief fill E2 connection update item
6501 * Function : fillE2connectionUpdateItem
6503 * Functionality: fill E2 connection update item
6506 * E2connectionUpdate Item to be filled
6508 * @return ROK - success
6510 * ****************************************************************/
6512 uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId)
6514 E2connectionUpdateRemove_Item_t *connectionRemoveITem=NULLP;
6515 E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
6516 TNLinformation_t *tnlInformation = NULLP;
6517 TNLusage_t *tnlUsage=NULLP;
6521 case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
6523 connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
6524 tnlInformation = &connectionModifyItem->tnlInformation;
6525 tnlUsage = &connectionModifyItem->tnlUsage;
6529 case ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item:
6531 connectionRemoveITem = (E2connectionUpdateRemove_Item_t*)connectionInfo;
6532 tnlInformation= &connectionRemoveITem->tnlInformation;
6537 tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
6538 RIC_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
6539 if(!tnlInformation->tnlAddress.buf)
6541 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6545 tnlInformation->tnlAddress.buf[3] = ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr & 0xFF;
6546 tnlInformation->tnlAddress.buf[2] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 8) & 0xFF;
6547 tnlInformation->tnlAddress.buf[1] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 16) & 0xFF;
6548 tnlInformation->tnlAddress.buf[0] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 24) & 0xFF;
6549 tnlInformation->tnlAddress.bits_unused = 0;
6550 if(protocolId == ProtocolIE_IDE2_id_E2connectionUpdate_Item)
6552 *tnlUsage = TNLusage_support_function;
6557 /*******************************************************************
6559 * @brief Build E2 connection modification list
6563 * Function : BuildE2ConnectionModifyList
6565 * Functionality: Build E2 connection modification list
6568 * E2 connection modification list to be filled
6570 * @return ROK - success
6572 * ****************************************************************/
6574 uint8_t BuildE2ConnectionModifyList(E2connectionUpdate_List_t *connectionToBeModifyList)
6577 E2connectionUpdate_ItemIEs_t *connectionModify=NULL;
6579 connectionToBeModifyList->list.count = 1;
6581 connectionToBeModifyList->list.size = connectionToBeModifyList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
6582 RIC_ALLOC(connectionToBeModifyList->list.array, connectionToBeModifyList->list.size);
6583 if(connectionToBeModifyList->list.array)
6585 for(arrIdx = 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
6587 RIC_ALLOC(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
6588 if(connectionToBeModifyList->list.array[arrIdx] == NULLP)
6590 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6593 connectionModify = (E2connectionUpdate_ItemIEs_t*)connectionToBeModifyList->list.array[arrIdx];
6594 connectionModify->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
6595 connectionModify->criticality= CriticalityE2_ignore;
6596 connectionModify->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
6597 if(fillE2connectionUpdateItem((PTR)&connectionModify->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_Item) != ROK)
6599 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
6607 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6613 /*******************************************************************
6615 * @brief Build E2 connection remove list
6619 * Function : BuildE2ConnectionRemoveList
6621 * Functionality: Build E2 connection remove list
6624 * E2 connection remove list to be filled
6626 * @return ROK - success
6628 * ****************************************************************/
6630 uint8_t BuildE2ConnectionRemoveList(E2connectionUpdateRemove_List_t *connectionToBeRemoveList)
6633 E2connectionUpdateRemove_ItemIEs_t *connectionRemove=NULL;
6635 connectionToBeRemoveList->list.count = 1;
6637 connectionToBeRemoveList->list.size = connectionToBeRemoveList->list.count*sizeof(E2connectionUpdateRemove_ItemIEs_t*);
6638 RIC_ALLOC(connectionToBeRemoveList->list.array, connectionToBeRemoveList->list.size);
6639 if(connectionToBeRemoveList->list.array)
6641 for(arrIdx = 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
6643 RIC_ALLOC(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
6644 if(connectionToBeRemoveList->list.array[arrIdx] == NULLP)
6646 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6649 connectionRemove = (E2connectionUpdateRemove_ItemIEs_t*)connectionToBeRemoveList->list.array[arrIdx];
6650 connectionRemove->id = ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item;
6651 connectionRemove->criticality= CriticalityE2_ignore;
6652 connectionRemove->value.present = E2connectionUpdateRemove_ItemIEs__value_PR_E2connectionUpdateRemove_Item;
6653 if(fillE2connectionUpdateItem((PTR)&connectionRemove->value.choice.E2connectionUpdateRemove_Item, ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item) != ROK)
6655 DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
6663 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6669 /*******************************************************************
6671 * @brief Deallocate the memory allocated for E2ConnectionUpdate msg
6675 * Function : FreeE2ConnectionUpdate
6678 * - freeing the memory allocated for E2ConnectionUpdate
6680 * @params[in] E2AP_PDU_t *e2apMsg
6681 * @return ROK - success
6684 * ****************************************************************/
6685 void FreeE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
6687 uint8_t ieIdx =0, arrIdx=0;
6688 E2connectionUpdate_t *connectionUpdate = NULLP;
6689 E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
6690 E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
6692 if(e2apMsg != NULLP)
6694 if(e2apMsg->choice.initiatingMessage != NULLP)
6696 connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
6697 if(connectionUpdate->protocolIEs.list.array)
6699 for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
6701 if(connectionUpdate->protocolIEs.list.array[ieIdx])
6703 switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
6705 case ProtocolIE_IDE2_id_TransactionID:
6708 case ProtocolIE_IDE2_id_E2connectionUpdateModify:
6710 connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
6711 if(connectionToBeModifyList->list.array)
6713 for(arrIdx = 0; arrIdx < connectionToBeModifyList->list.count; arrIdx++)
6715 RIC_FREE(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
6717 RIC_FREE(connectionToBeModifyList->list.array, connectionToBeModifyList->list.size);
6722 case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
6724 connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
6725 if(connectionToBeRemoveList->list.array)
6727 for(arrIdx = 0; arrIdx < connectionToBeRemoveList->list.count; arrIdx++)
6729 RIC_FREE(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
6731 RIC_FREE(connectionToBeRemoveList->list.array, connectionToBeRemoveList->list.size);
6736 RIC_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
6739 RIC_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
6741 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6743 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6747 /*******************************************************************
6749 * @brief Buld and send the E2 Connection Update msg
6753 * Function : BuildAndSendE2ConnectionUpdate
6756 * - Buld and send the E2 Connection Update Message
6759 * E2 connection to be modify or delete
6760 * @return ROK - success
6763 * ****************************************************************/
6765 uint8_t BuildAndSendE2ConnectionUpdate(uint32_t duId, E2Connection connectionInfo)
6767 uint8_t ieIdx = 0, elementCnt = 0;
6768 uint8_t ret = RFAILED, duIdx =0;
6770 E2AP_PDU_t *e2apMsg = NULLP;
6771 E2connectionUpdate_t *e2ConnectionUpdate=NULLP;
6772 asn_enc_rval_t encRetVal; /* Encoder return value */
6774 DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Message\n");
6777 SEARCH_DU_DB(duIdx, duId, duDb);
6780 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6784 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6785 if(e2apMsg == NULLP)
6787 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6790 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6792 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6793 if(e2apMsg->choice.initiatingMessage == NULLP)
6795 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6799 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
6800 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6801 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2connectionUpdate;
6802 e2ConnectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
6805 if(connectionInfo == MODIFY_CONNECTION)
6807 if(connectionInfo == REMOVE_CONNECTION)
6810 e2ConnectionUpdate->protocolIEs.list.count = elementCnt;
6811 e2ConnectionUpdate->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdate_IEs_t*);
6812 RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array, e2ConnectionUpdate->protocolIEs.list.size);
6813 if(!e2ConnectionUpdate->protocolIEs.list.array)
6815 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6819 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6821 RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
6822 if(!e2ConnectionUpdate->protocolIEs.list.array[ieIdx])
6824 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
6828 if(ieIdx < elementCnt)
6832 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6833 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6834 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_TransactionID;
6835 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = assignTransactionId(duDb);
6837 if(connectionInfo == MODIFY_CONNECTION)
6840 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionUpdateModify;
6841 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6842 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdate_List;
6843 if(BuildE2ConnectionModifyList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List) != ROK)
6845 DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
6850 if(connectionInfo == REMOVE_CONNECTION)
6853 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionUpdateRemove;
6854 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6855 e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdateRemove_List;
6856 if(BuildE2ConnectionRemoveList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List) != ROK)
6858 DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
6863 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6865 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6867 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6868 if(encRetVal.encoded == ENCODE_FAIL)
6870 DU_LOG("\nERROR --> E2AP : Could not encode E2 connection update structure (at %s)\n",\
6871 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6876 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update \n");
6877 for(int i=0; i< encBufSize; i++)
6879 DU_LOG("%x",encBuf[i]);
6884 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
6886 DU_LOG("\nERROR --> E2AP : Failed to send E2 Connection Update");
6894 FreeE2ConnectionUpdate(e2apMsg);
6898 /******************************************************************
6900 * @brief Processes the E2 connection update failure msg
6904 * Function : procE2connectionUpdateFailure
6906 * Functionality: Processes the E2 connection update failure msg
6909 * E2 connection update failure information
6913 * ****************************************************************/
6914 void ProcE2connectionUpdateFailure(E2connectionUpdateFailure_t *updateFailure)
6918 CauseE2_t *cause = NULLP;
6922 DU_LOG("\nERROR --> E2AP : updateFailure pointer is null");
6926 if(!updateFailure->protocolIEs.list.array)
6928 DU_LOG("\nERROR --> E2AP : updateFailure array pointer is null");
6932 for(ieIdx=0; ieIdx < updateFailure->protocolIEs.list.count; ieIdx++)
6934 if(updateFailure->protocolIEs.list.array[ieIdx])
6936 switch(updateFailure->protocolIEs.list.array[ieIdx]->id)
6938 case ProtocolIE_IDE2_id_TransactionID:
6940 transId = updateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
6941 DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
6944 case ProtocolIE_IDE2_id_CauseE2:
6946 cause = &updateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
6947 printE2ErrorCause(cause);
6952 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%d]", updateFailure->protocolIEs.list.array[ieIdx]->id);
6960 /*******************************************************************
6962 * @brief process the E2 Connection update ack
6966 * Function : ProcE2ConnectionUpdateAck
6968 * Functionality: Process E2 Connection update ack
6972 * Pointer to Connection update ack
6975 ******************************************************************/
6977 void ProcE2ConnectionUpdateAck(uint32_t duId, E2connectionUpdateAcknowledge_t *connectionUpdateAck)
6979 uint16_t transId =0;
6980 uint32_t ipAddress=0;
6982 uint8_t ieIdx = 0, duIdx =0, arrIdx=0;
6983 E2connectionUpdate_Item_t *connectionSetupItem=NULLP;
6984 E2connectionUpdate_ItemIEs_t *connectionSetupItemIe=NULLP;
6985 E2connectionUpdate_List_t *connectionSetupList=NULLP;
6986 E2connectionSetupFailed_Item_t *setupFailedItem =NULLP;
6987 E2connectionSetupFailed_List_t *setupFailedList=NULLP;
6988 E2connectionSetupFailed_ItemIEs_t *setupFailedItemIe =NULLP;
6990 SEARCH_DU_DB(duIdx, duId, duDb);
6993 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
6997 if(!connectionUpdateAck)
6999 DU_LOG("\nERROR --> E2AP : connectionUpdateAck pointer is null");
7003 if(!connectionUpdateAck->protocolIEs.list.array)
7005 DU_LOG("\nERROR --> E2AP : connectionUpdateAck array pointer is null");
7009 for(ieIdx=0; ieIdx < connectionUpdateAck->protocolIEs.list.count; ieIdx++)
7011 if(connectionUpdateAck->protocolIEs.list.array[ieIdx])
7013 switch(connectionUpdateAck->protocolIEs.list.array[ieIdx]->id)
7015 case ProtocolIE_IDE2_id_TransactionID:
7017 transId = connectionUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
7020 DU_LOG("\nERROR --> E2AP : Received invalid trans id %d ",transId);
7025 case ProtocolIE_IDE2_id_E2connectionSetup:
7027 connectionSetupList=&connectionUpdateAck->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
7028 if(connectionSetupList->list.array)
7030 for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
7032 connectionSetupItemIe = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
7033 connectionSetupItem = &connectionSetupItemIe->value.choice.E2connectionUpdate_Item;
7034 bitStringToInt(&connectionSetupItem->tnlInformation.tnlAddress, &ipAddress);
7035 if(ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr == ipAddress)
7037 ricCb.ricCfgParams.sctpParams.usage = connectionSetupItem->tnlUsage;
7044 case ProtocolIE_IDE2_id_E2connectionSetupFailed:
7046 setupFailedList=&connectionUpdateAck->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
7047 if(setupFailedList->list.array)
7049 for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
7051 setupFailedItemIe = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
7052 setupFailedItem = &setupFailedItemIe->value.choice.E2connectionSetupFailed_Item;
7053 printE2ErrorCause(&setupFailedItem->cause);
7060 DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", connectionUpdateAck->protocolIEs.list.array[ieIdx]->id);
7068 /*******************************************************************
7070 * @brief Handles received E2AP message and sends back response
7074 * Function : E2APMsgHdlr
7077 * - Decodes received E2AP control message
7078 * - Prepares response message, encodes and sends to SCTP
7081 * @return ROK - success
7084 * ****************************************************************/
7085 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
7091 E2AP_PDU_t *e2apMsg;
7092 asn_dec_rval_t rval; /* Decoder return value */
7093 E2AP_PDU_t e2apasnmsg ;
7095 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
7096 ODU_PRINT_MSG(mBuf, 0,0);
7098 /* Copy mBuf into char array to decode it */
7099 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
7100 RIC_ALLOC(recvBuf, (Size)recvBufLen);
7102 if(recvBuf == NULLP)
7104 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
7107 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
7109 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
7113 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
7114 for(i=0; i< recvBufLen; i++)
7116 DU_LOG("%x",recvBuf[i]);
7119 /* Decoding flat buffer into E2AP messsage */
7120 e2apMsg = &e2apasnmsg;
7121 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
7123 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
7124 RIC_FREE(recvBuf, (Size)recvBufLen);
7126 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
7128 DU_LOG("\nERROR --> E2AP : ASN decode failed");
7132 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7134 switch(e2apMsg->present)
7136 case E2AP_PDU_PR_initiatingMessage:
7138 switch(e2apMsg->choice.initiatingMessage->value.present)
7140 case InitiatingMessageE2__value_PR_E2setupRequest:
7142 DU_LOG("\nINFO --> E2AP : E2 setup request received");
7143 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
7146 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
7148 DU_LOG("\nINFO --> E2AP : E2 node config update received");
7149 ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate);
7152 case InitiatingMessageE2__value_PR_ResetRequestE2:
7154 DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
7155 ProcResetRequest(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
7158 case InitiatingMessageE2__value_PR_RICindication:
7160 DU_LOG("\nINFO --> E2AP : RIC Indication received");
7163 case InitiatingMessageE2__value_PR_RICserviceUpdate:
7165 DU_LOG("\nINFO --> E2AP : RIC Service update received");
7166 ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate);
7169 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired:
7171 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Required");
7172 ProcRicSubsModReqd(*duId, \
7173 &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired);
7176 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired:
7178 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Required");
7179 ProcRicSubsDeleteReqd(*duId, \
7180 &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired);
7184 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
7186 DU_LOG("\nINFO --> E2AP : Error indication received");
7189 case InitiatingMessageE2__value_PR_E2RemovalRequest:
7191 DU_LOG("\nINFO --> E2AP : E2 Removal request received");
7192 procE2RemovalRequest(*duId,\
7193 &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest);
7198 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \
7199 e2apMsg->choice.initiatingMessage->value.present);
7202 }/* End of switch(initiatingMessage) */
7205 case E2AP_PDU_PR_successfulOutcome:
7207 switch(e2apMsg->choice.successfulOutcome->value.present)
7209 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
7211 DU_LOG("\nINFO --> E2AP : Reset response received");
7212 ProcResetResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2);
7215 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
7217 ProcRicSubscriptionResponse(*duId, \
7218 &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse);
7221 case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
7223 ProcE2RemovalResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse);
7226 case SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge:
7228 ProcE2ConnectionUpdateAck(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge);
7233 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \
7234 e2apMsg->choice.successfulOutcome->value.present);
7241 case E2AP_PDU_PR_unsuccessfulOutcome:
7243 switch(e2apMsg->choice.successfulOutcome->value.present)
7245 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure:
7247 ProcRicSubscriptionFailure(*duId, \
7248 &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure);
7251 case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
7253 ProcE2RemovalFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure);
7256 case UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure:
7258 ProcE2connectionUpdateFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure);
7263 DU_LOG("\nERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \
7264 e2apMsg->choice.unsuccessfulOutcome->value.present);
7272 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
7276 }/* End of switch(e2apMsg->present) */
7277 } /* End of E2APMsgHdlr */
7280 /**********************************************************************
7282 **********************************************************************/