From 61f1d2eec53a339d27c720eee5ded1869ec72fbb Mon Sep 17 00:00:00 2001 From: pborla Date: Thu, 30 Nov 2023 16:13:55 +0530 Subject: [PATCH] [Epic-ID: ODUHIGH-516][Task-ID: ODUHIGH-530] RIC Subscription Modification Response Change-Id: I034a7eb020ee84d4cab8da6783cf181434d30bce Signed-off-by: pborla --- src/du_app/du_e2ap_mgr.c | 77 ++++- src/du_app/du_e2ap_mgr.h | 3 +- src/du_app/du_e2ap_msg_hdl.c | 674 ++++++++++++++++++++++++++++++++++++++++ src/du_app/du_e2ap_msg_hdl.h | 1 + src/ric_stub/ric_e2ap_msg_hdl.c | 374 +++++++++++++++++++++- 5 files changed, 1114 insertions(+), 15 deletions(-) diff --git a/src/du_app/du_e2ap_mgr.c b/src/du_app/du_e2ap_mgr.c index dad3428b9..99b36230d 100644 --- a/src/du_app/du_e2ap_mgr.c +++ b/src/du_app/du_e2ap_mgr.c @@ -690,7 +690,7 @@ uint8_t procStatsRspForSubsModReq(MacStatsRsp *statsRsp, RanFunction *ranFuncDb, /* Step - 4 */ pendingSubsModRsp->addActionCompleted =true; - if(duProcPendingSubsModRsp(pendingSubsModRsp) != ROK) + if(duProcPendingSubsModRsp(ricSubscriptionInfo, pendingSubsModRsp) != ROK) { DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__); return RFAILED; @@ -1848,7 +1848,7 @@ uint8_t e2ProcActionDeleteRsp(MacStatsDeleteRsp *statsDeleteRsp) /* [Step-4] */ pendingSubsModRsp->removeActionCompleted = true; - if(duProcPendingSubsModRsp(pendingSubsModRsp) != ROK) + if(duProcPendingSubsModRsp(ricSubscriptionInfo, pendingSubsModRsp) != ROK) { DU_LOG("\nERROR --> E2AP : failed to process subscription modification rsp"); return RFAILED; @@ -1869,23 +1869,76 @@ uint8_t e2ProcActionDeleteRsp(MacStatsDeleteRsp *statsDeleteRsp) * If processing of add, mod and remove action completes * then send the ric sub modification rsp * - * @params[in] Pending Subs modification rsp + * @params[in] + * Ric subscription info + * Pending Subs modification rsp * * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t duProcPendingSubsModRsp( PendingSubsModRspInfo *pendingSubsModRsp) +uint8_t duProcPendingSubsModRsp(RicSubscription *ricSubscriptionInfo, PendingSubsModRspInfo *pendingSubsModRsp) { - if(pendingSubsModRsp->addActionCompleted && pendingSubsModRsp->removeActionCompleted && pendingSubsModRsp->modActionCompleted) + uint8_t ret = RFAILED; + uint32_t reportingPeriod = 0; + + while(true) { -#if 0 - BuildAndSendRicSubsModRsp(pendingSubsModRsp); -#endif - memset(pendingSubsModRsp, 0, sizeof(PendingSubsModRspInfo)); - DU_LOG("\nProcessing of RIC subscription modification completed"); + if(pendingSubsModRsp->addActionCompleted && pendingSubsModRsp->removeActionCompleted && pendingSubsModRsp->modActionCompleted) + { + switch(ricSubscriptionInfo->eventTriggerDefinition.formatType) + { + case 1: + { + reportingPeriod = ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod; + storeReportStartTime(&ricSubscriptionInfo->eventTriggerDefinition.choice.format1.startTime); + break; + } + default: + { + DU_LOG("\nERROR --> E2AP : Invalid event trigger format of RIC subscription"); + break; + } + } + if(reportingPeriod == 0) + { + DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__); + break; + } + + if(duChkTmr((PTR)ricSubscriptionInfo, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR) != true) + { + duStartTmr((PTR)ricSubscriptionInfo, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR, reportingPeriod); + } + else + { + DU_LOG("\nERROR --> E2AP : RIC Subscription reporting timer already running for RIC Subscription"); + break; + } + + if(BuildAndSendRicSubscriptionModificationResponse(pendingSubsModRsp) != ROK) + { + DU_LOG("\nERROR --> E2AP : failed in function %s at line %d",__func__,__LINE__); + break; + } + + memset(pendingSubsModRsp, 0, sizeof(PendingSubsModRspInfo)); + DU_LOG("\nProcessing of RIC subscription modification completed"); + ret = ROK; + break; + } + else + { + ret = ROK; + break; + } } - return ROK; + + if(ret == RFAILED) + { + memset(pendingSubsModRsp, 0, sizeof(PendingSubsModRspInfo)); + } + return ret; } /******************************************************************* * @@ -2003,7 +2056,7 @@ uint8_t e2ProcStatsModificationRsp(MacStatsModificationRsp *statsModificationRsp /* [Step-5] */ pendingSubsModRsp->modActionCompleted = true; - if(duProcPendingSubsModRsp(pendingSubsModRsp) != ROK) + if(duProcPendingSubsModRsp(ricSubscriptionInfo, pendingSubsModRsp) != ROK) { DU_LOG("\nERROR --> E2AP : failed to process subscription modification rsp"); return RFAILED; diff --git a/src/du_app/du_e2ap_mgr.h b/src/du_app/du_e2ap_mgr.h index dea3f1bff..9ad52ad0a 100644 --- a/src/du_app/du_e2ap_mgr.h +++ b/src/du_app/du_e2ap_mgr.h @@ -559,7 +559,8 @@ uint8_t e2ProcStatsDeleteRsp(MacStatsDeleteRsp *statsDeleteRsp); uint8_t fillRicSubsInMacStatsModificationReq(MacStatsModificationReq *macStatsModReq, RicSubscription* ricSubscriptionInfo); uint8_t e2ProcActionDeleteRsp(MacStatsDeleteRsp *statsDeleteRsp); uint8_t e2ProcStatsModificationRsp(MacStatsModificationRsp *statsModificationRsp); -uint8_t duProcPendingSubsModRsp( PendingSubsModRspInfo *pendingSubsModRsp); +uint8_t duProcPendingSubsModRsp(RicSubscription *ricSubscriptionInfo, PendingSubsModRspInfo *pendingSubsModRsp); + /********************************************************************** End of file **********************************************************************/ diff --git a/src/du_app/du_e2ap_msg_hdl.c b/src/du_app/du_e2ap_msg_hdl.c index 5a3c425a6..4f04acab1 100644 --- a/src/du_app/du_e2ap_msg_hdl.c +++ b/src/du_app/du_e2ap_msg_hdl.c @@ -10128,6 +10128,11 @@ void procRicSubscriptionModificationRequest(E2AP_PDU_t *e2apMsg) } else { + if(duChkTmr((PTR)ricSubsDb, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR) == true) + { + duStopTmr((PTR)ricSubsDb, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR); + } + ricSubsDb->action = CONFIG_MOD; ranFuncDb->numPendingSubsModRsp++; @@ -10338,6 +10343,675 @@ uint8_t BuildAndSendRicSubscriptionModificationFailure(uint16_t ranFuncId, RicR return ret; } +/******************************************************************* + * @brief Free RIC Subscription Modification Response Message + * + * @details + * + * Function : FreeRicSubscriptionModificationResponse + * + * Functionality: Free RIC Subscription Modification Response + * + * @param E2AP Message PDU + * @return void + * + ******************************************************************/ +void FreeRicSubscriptionModificationResponse(E2AP_PDU_t *e2apMsg) +{ + uint8_t ieIdx = 0, elementIdx=0; + RICactions_AddedForModification_List_t *actionsAdded = NULLP; + RICactions_RemovedForModification_List_t *actionsRemoved = NULLP; + RICactions_ModifiedForModification_List_t *actionsModified = NULLP; + RICactions_FailedToBeAddedForModification_List_t *actionsFailedToBeAdded = NULLP; + RICactions_FailedToBeRemovedForModification_List_t *actionsFailedToBeRemoved = NULLP; + RICactions_FailedToBeModifiedForModification_List_t *actionsFailedToBeModified = NULLP; + + RICsubscriptionModificationResponse_t *ricSubsModResponse = NULLP; + + if(e2apMsg) + { + if(e2apMsg->choice.successfulOutcome) + { + ricSubsModResponse = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse; + if(ricSubsModResponse->protocolIEs.list.array) + { + for(ieIdx = 0; ieIdx < ricSubsModResponse->protocolIEs.list.count; ieIdx++) + { + if(ricSubsModResponse->protocolIEs.list.array[ieIdx]) + { + switch(ricSubsModResponse->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_RANfunctionID: + case ProtocolIE_IDE2_id_RICrequestID: + break; + case ProtocolIE_IDE2_id_RICactionsRemovedForModification_List: + { + actionsRemoved = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_RemovedForModification_List; + if(actionsRemoved->list.array) + { + for(elementIdx = 0; elementIdx < actionsRemoved->list.count; elementIdx++) + { + DU_FREE(actionsRemoved->list.array[elementIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t)); + } + DU_FREE(actionsRemoved->list.array, actionsRemoved->list.size); + } + break; + } + + case ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List: + { + actionsFailedToBeRemoved = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeRemovedForModification_List; + if(actionsFailedToBeRemoved->list.array) + { + for(elementIdx = 0; elementIdx < actionsFailedToBeRemoved->list.count; elementIdx++) + { + DU_FREE(actionsFailedToBeRemoved->list.array[elementIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t)); + } + DU_FREE(actionsFailedToBeRemoved->list.array, actionsFailedToBeRemoved->list.size); + } + break; + } + case ProtocolIE_IDE2_id_RICactionsModifiedForModification_List: + { + actionsModified = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_ModifiedForModification_List; + if(actionsModified->list.array) + { + for(elementIdx = 0; elementIdx < actionsModified->list.count; elementIdx++) + { + DU_FREE(actionsModified->list.array[elementIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t)); + } + DU_FREE(actionsModified->list.array, actionsModified->list.size); + } + break; + } + case ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List: + { + actionsFailedToBeModified = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeModifiedForModification_List; + if(actionsFailedToBeModified->list.array) + { + for(elementIdx = 0; elementIdx < actionsFailedToBeModified->list.count; elementIdx++) + { + DU_FREE(actionsFailedToBeModified->list.array[elementIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t)); + } + DU_FREE(actionsFailedToBeModified->list.array, actionsFailedToBeModified->list.size); + } + break; + } + case ProtocolIE_IDE2_id_RICactionsAddedForModification_List: + { + actionsAdded = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_AddedForModification_List; + if(actionsAdded->list.array) + { + for(elementIdx = 0; elementIdx < actionsAdded->list.count; elementIdx++) + { + DU_FREE(actionsAdded->list.array[elementIdx], sizeof(RICaction_AddedForModification_ItemIEs_t)); + } + DU_FREE(actionsAdded->list.array, actionsAdded->list.size); + } + break; + } + case ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List: + { + actionsFailedToBeAdded = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeAddedForModification_List; + if(actionsFailedToBeAdded->list.array) + { + for(elementIdx = 0; elementIdx < actionsFailedToBeAdded->list.count; elementIdx++) + { + DU_FREE(actionsFailedToBeAdded->list.array[elementIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t)); + } + DU_FREE(actionsFailedToBeAdded->list.array, actionsFailedToBeAdded->list.size); + } + break; + } + } + DU_FREE(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t)); + } + } + DU_FREE(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size); + } + DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); + } + DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));; + } +} + +/******************************************************************* +* +* @brief Build Ric subscription action removed list +* +* @details +* +* Function : BuildActionRemovedList +* +* Functionality: Build Ric subs action removed list +* +* @params[in] +* RICactions_RemovedForModification_List_t to be filled +* Num Of Action removed +* Action removed list +* +* @return ROK - success +* RFAILED - failure +* +******************************************************************/ + +uint8_t BuildActionRemovedList(RICactions_RemovedForModification_List_t *removedActionList, uint8_t numOfActionRemoved, uint8_t *actionRemoved) +{ + uint8_t arrIdx=0; + RICaction_RemovedForModification_ItemIEs_t *removedActionItemIe =NULLP; + + removedActionList->list.count = numOfActionRemoved; + removedActionList->list.size = removedActionList->list.count * sizeof(RICaction_RemovedForModification_ItemIEs_t*); + DU_ALLOC(removedActionList->list.array, removedActionList->list.size); + if(!removedActionList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx< removedActionList->list.count; arrIdx++) + { + DU_ALLOC(removedActionList->list.array[arrIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t)); + if(!removedActionList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + removedActionItemIe = (RICaction_RemovedForModification_ItemIEs_t*)removedActionList->list.array[arrIdx]; + removedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_RemovedForModification_Item; + removedActionItemIe->criticality = CriticalityE2_ignore; + removedActionItemIe->value.present = RICaction_RemovedForModification_ItemIEs__value_PR_RICaction_RemovedForModification_Item; + removedActionItemIe->value.choice.RICaction_RemovedForModification_Item.ricActionID = actionRemoved[arrIdx]; + } + return ROK; +} + +/******************************************************************* +* +* @brief Build Ric subscription action added list +* +* @details +* +* Function : BuildActionAddedList +* +* Functionality: Build Ric subs action added list +* +* @params[in] +* RICactions_AddedForModification_List_t to be filled +* Num Of Action added +* Action added list +* +* @return ROK - success +* RFAILED - failure +* +******************************************************************/ + +uint8_t BuildActionAddedList(RICactions_AddedForModification_List_t *addedActionList, uint8_t numOfActionAdded, uint8_t *actionAdded) +{ + uint8_t arrIdx=0; + RICaction_AddedForModification_ItemIEs_t *addedActionItemIe =NULLP; + + addedActionList->list.count = numOfActionAdded; + addedActionList->list.size = addedActionList->list.count * sizeof(RICaction_AddedForModification_ItemIEs_t*); + DU_ALLOC(addedActionList->list.array, addedActionList->list.size); + if(!addedActionList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx< addedActionList->list.count; arrIdx++) + { + DU_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_AddedForModification_ItemIEs_t)); + if(!addedActionList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + addedActionItemIe = (RICaction_AddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx]; + addedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_AddedForModification_Item; + addedActionItemIe->criticality = CriticalityE2_ignore; + addedActionItemIe->value.present = RICaction_AddedForModification_ItemIEs__value_PR_RICaction_AddedForModification_Item; + addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID = actionAdded[arrIdx]; + } + return ROK; +} + +/******************************************************************* +* +* @brief Build Ric subscription action modified list +* +* @details +* +* Function : BuildActionModifiedList +* +* Functionality: Build Ric subs action modified list +* +* @params[in] +* RICactions_ModifiedForModification_List_t to be filled +* Num Of Action modified +* Action modified list +* +* @return ROK - success +* RFAILED - failure +* +******************************************************************/ + +uint8_t BuildActionModifiedList(RICactions_ModifiedForModification_List_t *modifiedActionList, uint8_t numOfActionModified, uint8_t *actionModified) +{ + uint8_t arrIdx=0; + RICaction_ModifiedForModification_ItemIEs_t *modifiedActionItemIe =NULLP; + + modifiedActionList->list.count = numOfActionModified; + modifiedActionList->list.size = modifiedActionList->list.count * sizeof(RICaction_ModifiedForModification_ItemIEs_t*); + DU_ALLOC(modifiedActionList->list.array, modifiedActionList->list.size); + if(!modifiedActionList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx< modifiedActionList->list.count; arrIdx++) + { + DU_ALLOC(modifiedActionList->list.array[arrIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t)); + if(!modifiedActionList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + modifiedActionItemIe = (RICaction_ModifiedForModification_ItemIEs_t*)modifiedActionList->list.array[arrIdx]; + modifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ModifiedForModification_Item; + modifiedActionItemIe->criticality = CriticalityE2_ignore; + modifiedActionItemIe->value.present = RICaction_ModifiedForModification_ItemIEs__value_PR_RICaction_ModifiedForModification_Item; + modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID = actionModified[arrIdx]; + } + return ROK; +} + +/******************************************************************* + * + * @brief Build Ric subscription action failed to be removed list + * + * @details + * + * Function : BuildActionFailedToBeRemovedList + * + * Functionality: Build Ric subs action failed to be removed list + * + * @params[in] + * RICactions_FailedToBeRemovedForModification_List_t to be filled + * Num Of Action failed to be removed + * Action failed to be removed list + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t BuildActionFailedToBeRemovedList(RICactions_FailedToBeRemovedForModification_List_t *failedToBeRemovedActionList,\ +uint8_t numOfActionFailedToBeRemoved, RejectedAction *actionFailedToBeRemoved) +{ + uint8_t arrIdx=0; + RICaction_FailedToBeRemovedForModification_ItemIEs_t *failedToBeRemovedActionItemIe =NULLP; + + failedToBeRemovedActionList->list.count = numOfActionFailedToBeRemoved; + failedToBeRemovedActionList->list.size = failedToBeRemovedActionList->list.count * sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t*); + DU_ALLOC(failedToBeRemovedActionList->list.array, failedToBeRemovedActionList->list.size); + if(!failedToBeRemovedActionList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx< failedToBeRemovedActionList->list.count; arrIdx++) + { + DU_ALLOC(failedToBeRemovedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t)); + if(!failedToBeRemovedActionList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + failedToBeRemovedActionItemIe = (RICaction_FailedToBeRemovedForModification_ItemIEs_t*)failedToBeRemovedActionList->list.array[arrIdx]; + failedToBeRemovedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeRemovedForModification_Item; + failedToBeRemovedActionItemIe->criticality = CriticalityE2_ignore; + failedToBeRemovedActionItemIe->value.present = RICaction_FailedToBeRemovedForModification_ItemIEs__value_PR_RICaction_FailedToBeRemovedForModification_Item; + failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID = actionFailedToBeRemoved[arrIdx].id; + fillE2Cause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause, actionFailedToBeRemoved[arrIdx].failureCause); + } + return ROK; +} + +/******************************************************************* + * + * @brief Build Ric subscription action failed to be modified list + * + * @details + * + * Function : BuildActionFailedToBeModifiedList + * + * Functionality: Build Ric subs action failed to be modified list + * + * @params[in] + * RICactions_FailedToBeModifiedForModification_List_t to be filled + * Num Of Action failed to be modified + * Action failed to be modified list + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t BuildActionFailedToBeModifiedList(RICactions_FailedToBeModifiedForModification_List_t *failedToBeModifiedActionList,\ +uint8_t numOfActionFailedToBeModified, RejectedAction *actionFailedToBeModified) +{ + uint8_t arrIdx=0; + RICaction_FailedToBeModifiedForModification_ItemIEs_t *failedToBeModifiedActionItemIe =NULLP; + + failedToBeModifiedActionList->list.count = numOfActionFailedToBeModified; + failedToBeModifiedActionList->list.size = failedToBeModifiedActionList->list.count * sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t*); + DU_ALLOC(failedToBeModifiedActionList->list.array, failedToBeModifiedActionList->list.size); + if(!failedToBeModifiedActionList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx< failedToBeModifiedActionList->list.count; arrIdx++) + { + DU_ALLOC(failedToBeModifiedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t)); + if(!failedToBeModifiedActionList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + failedToBeModifiedActionItemIe = (RICaction_FailedToBeModifiedForModification_ItemIEs_t*)failedToBeModifiedActionList->list.array[arrIdx]; + failedToBeModifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeModifiedForModification_Item; + failedToBeModifiedActionItemIe->criticality = CriticalityE2_ignore; + failedToBeModifiedActionItemIe->value.present = RICaction_FailedToBeModifiedForModification_ItemIEs__value_PR_RICaction_FailedToBeModifiedForModification_Item; + failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID = actionFailedToBeModified[arrIdx].id; + fillE2Cause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause, actionFailedToBeModified[arrIdx].failureCause); + } + return ROK; +} + +/******************************************************************* + * + * @brief Build Ric subscription action failed to be added list + * + * @details + * + * Function : BuildActionFailedToBeAddedList + * + * Functionality: Build Ric subs action failed to be added list + * + * @params[in] + * RICactions_FailedToBeAddedForModification_List_t to be filled + * Num Of Action failed to be added + * Action failed to be added list + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t BuildActionFailedToBeAddedList(RICactions_FailedToBeAddedForModification_List_t *failedToBeAddedActionList, uint8_t numOfActionFailedToBeAdded, RejectedAction *actionFailedToBeAdded) +{ + uint8_t arrIdx=0; + RICaction_FailedToBeAddedForModification_ItemIEs_t *failedToBeAddedActionItemIe =NULLP; + + failedToBeAddedActionList->list.count = numOfActionFailedToBeAdded; + failedToBeAddedActionList->list.size = failedToBeAddedActionList->list.count * sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t*); + DU_ALLOC(failedToBeAddedActionList->list.array, failedToBeAddedActionList->list.size); + if(!failedToBeAddedActionList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx< failedToBeAddedActionList->list.count; arrIdx++) + { + DU_ALLOC(failedToBeAddedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t)); + if(!failedToBeAddedActionList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + failedToBeAddedActionItemIe = (RICaction_FailedToBeAddedForModification_ItemIEs_t*)failedToBeAddedActionList->list.array[arrIdx]; + failedToBeAddedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeAddedForModification_Item; + failedToBeAddedActionItemIe->criticality = CriticalityE2_ignore; + failedToBeAddedActionItemIe->value.present = RICaction_FailedToBeAddedForModification_ItemIEs__value_PR_RICaction_FailedToBeAddedForModification_Item; + failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.ricActionID = actionFailedToBeAdded[arrIdx].id; + fillE2Cause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause, actionFailedToBeAdded[arrIdx].failureCause); + } + return ROK; +} + +/******************************************************************* + * + * @brief Builds and Send RIC Subscription Modification Response + * + * @details + * + * Function : BuildAndSendRicSubscriptionModificationResponse + * + * Functionality: Build and send RIC Subscription Modification Response. + * + * @params[in] + * PendingSubsModRspInfo + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t BuildAndSendRicSubscriptionModificationResponse(PendingSubsModRspInfo *pendingSubsModRsp) +{ + uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED; + E2AP_PDU_t *e2apMsg = NULLP; + RICsubscriptionModificationResponse_t *ricSubsModResponse = NULLP; + RICsubscriptionModificationResponse_IEs_t *ricSubsModResponseIe = NULLP; + asn_enc_rval_t encRetVal; /* Encoder return value */ + + while(true) + { + DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Response Message\n"); + + DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); + if(e2apMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__); + break; + } + + e2apMsg->present = E2AP_PDU_PR_successfulOutcome; + DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); + if(e2apMsg->choice.successfulOutcome == NULLP) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__); + break; + } + e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification; + e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject; + e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationResponse; + + + ricSubsModResponse = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse; + + elementCnt = 2; + if(pendingSubsModRsp->removeActionStatus.numOfAcceptedActions) + elementCnt++; + if(pendingSubsModRsp->addActionStatus.numOfAcceptedActions) + elementCnt++; + if(pendingSubsModRsp->modActionStatus.numOfAcceptedActions) + elementCnt++; + if(pendingSubsModRsp->removeActionStatus.numOfRejectedActions) + elementCnt++; + if(pendingSubsModRsp->addActionStatus.numOfRejectedActions) + elementCnt++; + if(pendingSubsModRsp->modActionStatus.numOfRejectedActions) + elementCnt++; + + ricSubsModResponse->protocolIEs.list.count = elementCnt; + ricSubsModResponse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationResponse_IEs_t *); + + DU_ALLOC(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size); + if(ricSubsModResponse->protocolIEs.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + for(ieIdx = 0; ieIdx < elementCnt; ieIdx++) + { + DU_ALLOC(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t)); + if(ricSubsModResponse->protocolIEs.list.array[ieIdx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + if(ieIdx < elementCnt) + break; + + ieIdx = 0; + ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx]; + ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICrequestID; + ricSubsModResponseIe->criticality = CriticalityE2_reject; + ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICrequestID; + ricSubsModResponseIe->value.choice.RICrequestID.ricRequestorID= pendingSubsModRsp->requestId.requestorId; + ricSubsModResponseIe->value.choice.RICrequestID.ricInstanceID = pendingSubsModRsp->requestId.instanceId; + + ieIdx++; + ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx]; + ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RANfunctionID; + ricSubsModResponseIe->criticality = CriticalityE2_reject; + ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RANfunctionID; + ricSubsModResponseIe->value.choice.RANfunctionID = pendingSubsModRsp->ranFuncId; + + if(pendingSubsModRsp->removeActionStatus.numOfAcceptedActions) + { + ieIdx++; + ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx]; + ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsRemovedForModification_List; + ricSubsModResponseIe->criticality = CriticalityE2_ignore; + ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_RemovedForModification_List; + if(BuildActionRemovedList(&ricSubsModResponseIe->value.choice.RICactions_RemovedForModification_List,\ + pendingSubsModRsp->removeActionStatus.numOfAcceptedActions, pendingSubsModRsp->removeActionStatus.acceptedActionList) != ROK) + { + DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + + if(pendingSubsModRsp->removeActionStatus.numOfRejectedActions) + { + ieIdx++; + ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx]; + ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List; + ricSubsModResponseIe->criticality = CriticalityE2_ignore; + ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeRemovedForModification_List; + if(BuildActionFailedToBeRemovedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeRemovedForModification_List,\ + pendingSubsModRsp->removeActionStatus.numOfRejectedActions, pendingSubsModRsp->removeActionStatus.rejectedActionList) != ROK) + { + DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + + if(pendingSubsModRsp->modActionStatus.numOfAcceptedActions) + { + ieIdx++; + ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx]; + ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsModifiedForModification_List; + ricSubsModResponseIe->criticality = CriticalityE2_ignore; + ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_ModifiedForModification_List; + if(BuildActionModifiedList(&ricSubsModResponseIe->value.choice.RICactions_ModifiedForModification_List,\ + pendingSubsModRsp->modActionStatus.numOfAcceptedActions, pendingSubsModRsp->modActionStatus.acceptedActionList) != ROK) + { + DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + + if(pendingSubsModRsp->modActionStatus.numOfRejectedActions) + { + ieIdx++; + ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx]; + ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List; + ricSubsModResponseIe->criticality = CriticalityE2_ignore; + ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeModifiedForModification_List; + if(BuildActionFailedToBeModifiedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeModifiedForModification_List,\ + pendingSubsModRsp->modActionStatus.numOfRejectedActions, pendingSubsModRsp->modActionStatus.rejectedActionList) != ROK) + { + DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + + if(pendingSubsModRsp->addActionStatus.numOfAcceptedActions) + { + ieIdx++; + ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx]; + ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsAddedForModification_List; + ricSubsModResponseIe->criticality = CriticalityE2_ignore; + ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_AddedForModification_List; + if(BuildActionAddedList(&ricSubsModResponseIe->value.choice.RICactions_AddedForModification_List,\ + pendingSubsModRsp->addActionStatus.numOfAcceptedActions, pendingSubsModRsp->addActionStatus.acceptedActionList) != ROK) + { + DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + + if(pendingSubsModRsp->addActionStatus.numOfRejectedActions) + { + ieIdx++; + ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx]; + ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List; + ricSubsModResponseIe->criticality = CriticalityE2_ignore; + ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeAddedForModification_List; + if(BuildActionFailedToBeAddedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeAddedForModification_List,\ + pendingSubsModRsp->addActionStatus.numOfRejectedActions, pendingSubsModRsp->addActionStatus.rejectedActionList) != ROK) + { + DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + + /* Prints the Msg formed */ + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf); + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modification Response Message (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Response Message \n"); +#ifdef DEBUG_ASN_PRINT + for(int i=0; i< encBufSize; i++) + { + printf("%x",encBuf[i]); + } +#endif + } + + if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Modification Response Message"); + break; + } + + ret = ROK; + break; + } + + FreeRicSubscriptionModificationResponse(e2apMsg); + return ret; +} + /******************************************************************* * * @brief Handles received E2AP message and sends back response diff --git a/src/du_app/du_e2ap_msg_hdl.h b/src/du_app/du_e2ap_msg_hdl.h index c433a6f5f..4f0d49113 100644 --- a/src/du_app/du_e2ap_msg_hdl.h +++ b/src/du_app/du_e2ap_msg_hdl.h @@ -34,6 +34,7 @@ uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo, ActionIn uint8_t BuildAndSendRicSubscriptionDeleteResponse(uint16_t ranFuncId, RicRequestId requestId); uint8_t BuildAndSendRicSubscriptionDeleteFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause); uint8_t BuildAndSendRicSubscriptionModificationFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause); +uint8_t BuildAndSendRicSubscriptionModificationResponse(PendingSubsModRspInfo *pendingSubsModRsp); /********************************************************************** End of file diff --git a/src/ric_stub/ric_e2ap_msg_hdl.c b/src/ric_stub/ric_e2ap_msg_hdl.c index b7a9eab75..36335528a 100644 --- a/src/ric_stub/ric_e2ap_msg_hdl.c +++ b/src/ric_stub/ric_e2ap_msg_hdl.c @@ -1996,6 +1996,7 @@ uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscr if(actionNode) { + cmLListDelFrm(&ricSubsDb->actionSequence, actionNode); deleteActionSequence(actionNode); } return RFAILED; @@ -2437,7 +2438,8 @@ void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricS action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode); if(action) { - deleteActionSequence(action); + cmLListDelFrm(&ricSubs->actionSequence, actionNode); + deleteActionSequence(actionNode); } } } @@ -4621,7 +4623,8 @@ uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t if(action) { tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId; - deleteActionSequence(action); + cmLListDelFrm(&ricSubs->actionSequence, actionNode); + deleteActionSequence(actionNode); } } break; @@ -8004,6 +8007,368 @@ void BuildRicSubsModificationReq(DuDb *duDb, RicSubscription *ricSubsInfo) } } +/**************************************************************** + * + * @brief Processing RIC Subscription action modified list + * + * @details + * + * Function :ProcessingRicSubsActionModified + * + * Functionality: Processing the RIC Subscription action modified list + * + * @params[in] RICactions_AddedForModification_List_t + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionModified(RICactions_ModifiedForModification_List_t *actionModifiedList) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + ActionInfo *action=NULLP; + CmLList *actionNode =NULLP; + RICaction_ModifiedForModification_ItemIEs_t *modifiedActionItemIe =NULLP; + + if(actionModifiedList->list.array) + { + for(elementIdx = 0; elementIdx < actionModifiedList->list.count; elementIdx++) + { + if(actionModifiedList->list.array[elementIdx]) + { + modifiedActionItemIe=(RICaction_ModifiedForModification_ItemIEs_t*)actionModifiedList->list.array[elementIdx]; + actionId = modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID; + DU_LOG("\nInfo --> E2AP : Action id %d modified successfully", actionId); + } + + } + + } +} + +/**************************************************************** + * + * @brief Processing RIC Subscription action added list + * + * @details + * + * Function : ProcessingRicSubsActionAdded + * + * Functionality: Processing RIC Subscription action added list + * + * @params[in] RICactions_AddedForModification_List_t + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionAdded(RICactions_AddedForModification_List_t *actionAddedList) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + ActionInfo *action=NULLP; + CmLList *actionNode =NULLP; + RICaction_AddedForModification_ItemIEs_t *addedActionItemIe =NULLP; + + if(actionAddedList->list.array) + { + for(elementIdx = 0; elementIdx < actionAddedList->list.count; elementIdx++) + { + if(actionAddedList->list.array[elementIdx]) + { + addedActionItemIe=(RICaction_AddedForModification_ItemIEs_t*)actionAddedList->list.array[elementIdx]; + actionId = addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID; + DU_LOG("\nInfo --> E2AP : Action id %d added successfully", actionId); + } + + } + + } +} + +/**************************************************************** + * + * @brief Processing RIC Subscription action deleted list + * + * @details + * + * Function : ProcessingRicSubsActionRemoved + * + * Functionality: Processing RIC Subscription action deleted list + * + * @params[in] RICactions_RemovedForModification_List_t + * Ric Subscription info + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionRemoved(RICactions_RemovedForModification_List_t *actionRemovedList, RicSubscription *ricSubs) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + ActionInfo *action=NULLP; + CmLList *actionNode =NULLP; + RICaction_RemovedForModification_ItemIEs_t *removedActionItemIe =NULLP; + + if(actionRemovedList->list.array) + { + for(elementIdx = 0; elementIdx < actionRemovedList->list.count; elementIdx++) + { + if(actionRemovedList->list.array[elementIdx]) + { + removedActionItemIe=(RICaction_RemovedForModification_ItemIEs_t*)actionRemovedList->list.array[elementIdx]; + actionId = removedActionItemIe->value.choice.RICaction_RemovedForModification_Item.ricActionID; + action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode); + if(action) + { + cmLListDelFrm(&ricSubs->actionSequence, actionNode); + deleteActionSequence(actionNode); + DU_LOG("\nInfo --> E2AP : Action id %d removed successfully", actionId); + } + } + + } + + } +} + +/******************************************************************* + * + * @brief Processing RIC Subscription action failed to be + * removed list + * + * @details + * + * Function : ProcessingRicSubsActionFailedToBeRemoved + * + * Functionality: Processing the RIC Subscription action failed + * to be removed list + * + * @params[in] RICactions_FailedToBeRemovedForModification_List_t + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionFailedToBeRemoved(RICactions_FailedToBeRemovedForModification_List_t *actionFailedToBeRemoved) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + RICaction_FailedToBeRemovedForModification_ItemIEs_t *failedToBeRemovedActionItemIe =NULLP; + + if(actionFailedToBeRemoved->list.array) + { + for(elementIdx = 0; elementIdx < actionFailedToBeRemoved->list.count; elementIdx++) + { + if(actionFailedToBeRemoved->list.array[elementIdx]) + { + failedToBeRemovedActionItemIe=(RICaction_FailedToBeRemovedForModification_ItemIEs_t*)actionFailedToBeRemoved->list.array[elementIdx]; + actionId = failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID; + DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId, __func__); + printE2ErrorCause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause); + } + + } + + } +} + +/**************************************************************** + * + * @brief Processing RIC Subscription action failed to be + * add list + * + * @details + * + * Function : ProcessingRicSubsActionFailedToBeAdded + * + * Functionality: Processing the RIC Subscription action failed + * to be add list + * + * @params[in] RICactions_FailedToBeAddedForModification_List_t + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionFailedToBeAdded(RICactions_FailedToBeAddedForModification_List_t *actionfailedToBeAddedList, RicSubscription *ricSubs) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + ActionInfo *action=NULLP; + CmLList *actionNode =NULLP; + RICaction_FailedToBeAddedForModification_ItemIEs_t *failedToBeAddedActionItemIe =NULLP; + + if(actionfailedToBeAddedList->list.array) + { + for(elementIdx = 0; elementIdx < actionfailedToBeAddedList->list.count; elementIdx++) + { + if(actionfailedToBeAddedList->list.array[elementIdx]) + { + failedToBeAddedActionItemIe=(RICaction_FailedToBeAddedForModification_ItemIEs_t*)actionfailedToBeAddedList->list.array[elementIdx]; + actionId = failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.ricActionID; + action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode); + if(action) + { + cmLListDelFrm(&ricSubs->actionSequence, actionNode); + deleteActionSequence(actionNode); + } + DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__); + printE2ErrorCause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause); + } + + } + + } +} + +/******************************************************************* + * + * @brief Processing RIC Subscription action failed to be + * modified list + * + * @details + * + * Function :ProcessingRicSubsActionFailedToBeModified + * + * Functionality: Processing the RIC Subscription action failed + * to be modified list + * + * @params[in] RICactions_FailedToBeModifiedForModification_List_t + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionFailedToBeModified(RICactions_FailedToBeModifiedForModification_List_t *actionFailedToBeModifiedList) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + RICaction_FailedToBeModifiedForModification_ItemIEs_t *failedToBeModifiedActionItemIe =NULLP; + + if(actionFailedToBeModifiedList->list.array) + { + for(elementIdx = 0; elementIdx < actionFailedToBeModifiedList->list.count; elementIdx++) + { + if(actionFailedToBeModifiedList->list.array[elementIdx]) + { + failedToBeModifiedActionItemIe=(RICaction_FailedToBeModifiedForModification_ItemIEs_t*)actionFailedToBeModifiedList->list.array[elementIdx]; + actionId = failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID; + DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__); + printE2ErrorCause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause); + } + + } + + } +} + +/****************************************************************** + * + * @brief Processes the Ric Subs modification rsp msg + * + * @details + * + * Function : ProcRicSubsModificationRsp + * + * Functionality: Processes the Ric Subs modification rsp msg + * + * @params[in] + * Ric Subs modification rsp information + * + * @return void + * + * ****************************************************************/ +void ProcRicSubsModificationRsp(uint32_t duId, RICsubscriptionModificationResponse_t *ricSubsModificationRsp) +{ + uint8_t ieIdx = 0; + uint8_t duIdx= 0; + uint16_t ranFuncId=0; + RanFunction *ranFuncDb = NULLP; + RicRequestId ricReqId; + DuDb *duDb = NULLP; + RicSubscription *ricSubs = NULLP; + CmLList *ricSubsNode = NULLP; + + SEARCH_DU_DB(duIdx, duId, duDb); + if(duDb == NULLP) + { + DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); + return; + } + + if(!ricSubsModificationRsp) + { + DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp pointer is null"); + return; + } + + if(!ricSubsModificationRsp->protocolIEs.list.array) + { + DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp array pointer is null"); + return; + } + + for(ieIdx=0; ieIdx < ricSubsModificationRsp->protocolIEs.list.count; ieIdx++) + { + if(ricSubsModificationRsp->protocolIEs.list.array[ieIdx]) + { + switch(ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_RICrequestID: + { + ricReqId.requestorId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricRequestorID; + ricReqId.instanceId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricInstanceID; + break; + } + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID; + ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId); + if(!ranFuncDb) + { + DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId); + return; + } + + ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode); + if(!ricSubs) + { + DU_LOG("\nERROR --> E2AP : Ric subscription node is not present "); + return; + } + break; + } + case ProtocolIE_IDE2_id_RICactionsRemovedForModification_List: + { + ProcessingRicSubsActionRemoved(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_RemovedForModification_List, ricSubs); + break; + } + case ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List: + { + ProcessingRicSubsActionFailedToBeRemoved(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeRemovedForModification_List); + break; + } + case ProtocolIE_IDE2_id_RICactionsModifiedForModification_List: + { + ProcessingRicSubsActionModified(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_ModifiedForModification_List); + break; + } + case ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List: + { + ProcessingRicSubsActionFailedToBeModified(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeModifiedForModification_List); + break; + } + case ProtocolIE_IDE2_id_RICactionsAddedForModification_List: + { + ProcessingRicSubsActionAdded(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_AddedForModification_List); + break; + } + case ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List: + { + ProcessingRicSubsActionFailedToBeAdded(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeAddedForModification_List, ricSubs); + break; + } + default: + { + DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id); + break; + } + } + } + } +} + /******************************************************************* * * @brief Handles received E2AP message and sends back response @@ -8172,6 +8537,11 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) ProcRicSubsDeleteRsp(*duId, &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse); break; } + case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationResponse: + { + ProcRicSubsModificationRsp(*duId, &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse); + break; + } default: { DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \ -- 2.16.6