X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_e2ap_msg_hdl.c;h=bfd29e8dd07f80e1eeb05c23528c943735e6fedc;hb=9bfd39713f94e019675b4a255855177462b39bbd;hp=bddc73b8161e1216ed08b26191f4a3c4c1fb2b2a;hpb=c371a26d48604a5d60686d9ca347e68671e69637;p=o-du%2Fl2.git diff --git a/src/du_app/du_e2ap_msg_hdl.c b/src/du_app/du_e2ap_msg_hdl.c index bddc73b81..bfd29e8dd 100644 --- a/src/du_app/du_e2ap_msg_hdl.c +++ b/src/du_app/du_e2ap_msg_hdl.c @@ -29,6 +29,7 @@ #include "du_sctp.h" #include "du_mgr.h" #include "du_mgr_main.h" +#include "du_msg_hdl.h" #include "du_utils.h" #include "GlobalE2node-gNB-ID.h" #include "ProtocolIE-FieldE2.h" @@ -645,7 +646,7 @@ void FreeErrorIndication(E2AP_PDU_t *e2apMsg) * ******************************************************************/ -uint8_t BuildAndSendErrorIndication(int8_t transId, RicRequestId requestId, uint16_t ranFuncId, E2FailureCause failureCause) +uint8_t BuildAndSendErrorIndication(uint16_t transId, RicRequestId requestId, uint16_t ranFuncId, E2FailureCause failureCause) { uint8_t elementCnt =0, arrIdx=0, ret = RFAILED; E2AP_PDU_t *e2apMsg = NULLP; @@ -834,7 +835,8 @@ void freeAperDecodingOfE2NodeConfigUpdateFailure(E2nodeConfigurationUpdateFailur void procE2NodeConfigUpdateFailure(E2AP_PDU_t *e2apMsg) { - uint8_t arrIdx =0, transId =0, timerValue=0; + uint8_t arrIdx =0, timerValue=0; + uint16_t transId =0; E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL; DU_LOG("\nINFO --> E2AP : E2 Node Config Update failure received"); @@ -1992,8 +1994,8 @@ void FreeE2SetupReq(E2AP_PDU_t *e2apMsg) uint8_t BuildAndSendE2SetupReq() { - uint8_t arrIdx = 0, elementCnt=0; - uint8_t transId = 0, ret = RFAILED; + uint16_t transId = 0; + uint8_t arrIdx = 0, elementCnt=0, ret =RFAILED; bool memAllocFailed = false; E2AP_PDU_t *e2apMsg = NULLP; E2setupRequest_t *e2SetupReq = NULLP; @@ -2703,9 +2705,14 @@ void handleE2NodeConfigUpdateAckIes(PTR e2NodeCfg, uint8_t procedureCode) void procE2SetupRsp(E2AP_PDU_t *e2apMsg) { bool invalidTransId = false; - uint8_t arrIdx =0, transId=0, idx=0; + uint8_t arrIdx =0, idx=0; + uint16_t transId=0; uint32_t recvBufLen; E2setupResponse_t *e2SetRspMsg=NULL; + RANfunctionsID_List_t *ranFuncAcceptedList=NULL; + RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL; + RANfunctionsIDcause_List_t *ranFuncRejectedList=NULL; + RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL; E2nodeComponentConfigAdditionAck_List_t *e2NodeCfgAckList=NULL; E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem=NULL; @@ -2752,11 +2759,31 @@ void procE2SetupRsp(E2AP_PDU_t *e2apMsg) { e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeCfgAckList->list.array[idx]; handleE2NodeConfigUpdateAckIes((PTR)&e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item,\ - ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck); + ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck); + } + break; + } + case ProtocolIE_IDE2_id_RANfunctionsAccepted: + { + ranFuncAcceptedList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List; + for(idx =0; idx list.count; idx++) + { + ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[idx]; + DU_LOG("\nINFO --> E2AP : Ran function id [%ld] accepted",ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID); } break; } + case ProtocolIE_IDE2_id_RANfunctionsRejected: + { + ranFuncRejectedList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List; + for(idx =0; idx list.count; idx++) + { + ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[idx]; + DU_LOG("\nINFO --> E2AP : Ran function id [%ld] rejected",ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID); + } + break; + } default: { DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld", @@ -3244,6 +3271,108 @@ uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefD return RFAILED; } +/******************************************************************* + * + * @brief add RIC Subs action info + * + * @details + * + * Function : addRicSubsAction + * + * Functionality: add Ric Subs action info + * + * @parameter + * RAN function DB + * Pointer to Ric Subc info + * Action Sequence list + * Procedure Code + * E2 Failure Cause + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +CmLList *addRicSubsAction(RanFunction *ranFuncDb, PTR ricSubsInfo, CmLListCp *actionSequence, uint8_t procedureCode, E2FailureCause *failureCause) +{ + CmLList *actionNode = NULLP; + ActionInfo *actionDb = NULLP; + RICactionID_t ricActionID; + RICactionType_t ricActionType; + RICactionDefinition_t *ricActionDefinition= NULLP; + RICaction_ToBeSetup_Item_t *setupItem= NULLP; + RICaction_ToBeAddedForModification_Item_t *addIem= NULLP; + RICaction_ToBeModifiedForModification_Item_t *modifiedItem= NULLP; + + switch(procedureCode) + { + case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item: + { + setupItem = (RICaction_ToBeSetup_Item_t *)ricSubsInfo; + ricActionID= setupItem->ricActionID; + ricActionType= setupItem->ricActionType; + if(setupItem->ricActionDefinition) + { + ricActionDefinition = setupItem->ricActionDefinition; + } + break; + } + case ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item: + { + addIem = (RICaction_ToBeAddedForModification_Item_t*) ricSubsInfo; + ricActionID= addIem->ricActionID; + ricActionType= addIem->ricActionType; + ricActionDefinition = &addIem->ricActionDefinition; + + break; + } + case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item: + { + modifiedItem= (RICaction_ToBeModifiedForModification_Item_t*)ricSubsInfo; + ricActionID= modifiedItem->ricActionID; + /* Added since ricActionType IE is not present in case of + * modification */ + ricActionType = RICactionType_report; + if(modifiedItem->ricActionDefinition) + { + ricActionDefinition = modifiedItem->ricActionDefinition; + } + break; + } + } + + + DU_ALLOC(actionDb, sizeof(ActionInfo)); + if(actionDb==NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__); + return NULLP; + } + if(ricActionType== RICactionType_report) + { + actionDb->actionId = ricActionID; + actionDb->type = REPORT; + + if(extractRicActionDef(ranFuncDb, &actionDb->definition, ricActionDefinition, failureCause) == ROK) + { + actionDb->action = CONFIG_ADD; + } + + DU_ALLOC(actionNode, sizeof(CmLList)); + if(actionNode) + { + actionNode->node = (PTR) actionDb; + cmLListAdd2Tail(actionSequence, actionNode); + } + else + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__); + DU_FREE(actionDb, sizeof(ActionInfo)); + return NULLP; + } + } + return actionNode; + +} /******************************************************************* * * @brief Extract RIC Action to be setup @@ -3266,6 +3395,7 @@ uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefD uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \ RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause, PendingSubsRspInfo *subsRsp) { + CmLList *actionNode = NULLP; uint8_t actionIdx = 0; uint8_t ricActionId = 0; RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP; @@ -3283,35 +3413,23 @@ uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSu * If RIC action definition's extraction and validation passes, * Then : * This action is added to action sequence list of subscription info */ - ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID; - - if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType == RICactionType_report) + actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeSetup_Item,\ + &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item, failureCause); + + if(!actionNode) { - ricSubscriptionInfo->actionSequence[ricActionId].actionId = ricActionId; - ricSubscriptionInfo->actionSequence[ricActionId].type = REPORT; - - if(extractRicActionDef(ranFuncDb, &ricSubscriptionInfo->actionSequence[ricActionId].definition, \ - actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, failureCause) == ROK) + /* In case of any failure, action is rejected + * Added to rejected-action-list in subscription response */ + subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId; + if(failureCause->causeType == E2_NOTHING) { - ricSubscriptionInfo->actionSequence[ricActionId].action = CONFIG_ADD; - ricSubscriptionInfo->numOfActions++; - break; + failureCause->causeType = E2_RIC_REQUEST; + failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE; } + memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \ + failureCause, sizeof(E2FailureCause)); + subsRsp->numOfRejectedActions++; } - - /* In case of any failure, action is rejected - * Added to rejected-action-list in subscription response */ - deleteActionSequence(&ricSubscriptionInfo->actionSequence[ricActionId]); - - subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId; - if(failureCause->causeType == E2_NOTHING) - { - failureCause->causeType = E2_RIC_REQUEST; - failureCause->cause = E2_ACTION_NOT_SUPPORTED; - } - memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \ - failureCause, sizeof(E2FailureCause)); - subsRsp->numOfRejectedActions++; break; } default: @@ -3322,7 +3440,7 @@ uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSu } /* If there is even 1 action that can be added, return ROK */ - if(ricSubscriptionInfo->numOfActions) + if(ricSubscriptionInfo->actionSequence.count) return ROK; if(failureCause->causeType == E2_NOTHING) @@ -3350,7 +3468,7 @@ uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSu * ****************************************************************/ uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg) { - uint8_t idx = 0, actionIdx = 0; + uint8_t idx = 0; uint8_t ret = ROK; uint16_t ranFuncId = 0; RicRequestId ricReqId; @@ -3417,11 +3535,6 @@ uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg) ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId; ricSubscriptionInfo->ranFuncId = ranFuncId; - for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++) - { - ricSubscriptionInfo->actionSequence[actionIdx].actionId = -1; - } - memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo)); memcpy(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].requestId, &ricReqId, sizeof(RicRequestId)); @@ -3479,10 +3592,8 @@ uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg) ranFuncDb->numPendingSubsRsp++; -#ifdef KPI_CALCULATION /* Send statistics request to other DU entities */ BuildAndSendStatsReq(ricSubscriptionInfo); -#endif } else { @@ -4786,7 +4897,8 @@ void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg) uint8_t BuildAndSendE2NodeConfigUpdate(E2NodeConfigList *e2NodeList) { uint8_t ret = RFAILED; - uint8_t arrIdx = 0,elementCnt = 0, transId=0; + uint8_t arrIdx = 0,elementCnt = 0; + uint16_t transId=0; E2AP_PDU_t *e2apMsg = NULLP; asn_enc_rval_t encRetVal; /* Encoder return value */ E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP; @@ -4994,7 +5106,8 @@ void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg) * ****************************************************************/ uint8_t BuildAndSendE2ResetRequest(E2FailureCause resetCause) { - uint8_t ieIdx = 0, elementCnt = 0, transId = 0; + uint8_t ieIdx = 0, elementCnt = 0; + uint16_t transId = 0; uint8_t ret = RFAILED; E2AP_PDU_t *e2apMsg = NULLP; ResetRequestE2_t *resetReq = NULLP; @@ -5167,7 +5280,8 @@ void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse) void procResetResponse(E2AP_PDU_t *e2apMsg) { bool invalidTransId=false; - uint8_t ieIdx =0, transId =0; + uint8_t ieIdx =0; + uint16_t transId =0; uint16_t ranFuncIdx=0; ResetResponseE2_t *resetResponse =NULLP; @@ -5273,7 +5387,8 @@ void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure) * ****************************************************************/ void procE2SetupFailure(E2AP_PDU_t *e2apMsg) { - uint8_t arrIdx =0, transId =0, timerValue=0; + uint16_t transId =0; + uint8_t arrIdx =0, timerValue=0; E2setupFailure_t *e2SetupFailure; DU_LOG("\nINFO --> E2AP : E2 Setup failure received"); @@ -5535,9 +5650,9 @@ void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg) uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate) { - uint8_t arrIdx = 0, elementCnt=0; - uint8_t transId = 0, ret = RFAILED; + uint16_t transId = 0; bool memAllocFailed =false; + uint8_t arrIdx = 0, elementCnt=0,ret = RFAILED; E2AP_PDU_t *e2apMsg = NULLP; RICserviceUpdate_t *ricServiceUpdate = NULLP; asn_enc_rval_t encRetVal; /* Encoder return value */ @@ -5883,7 +5998,8 @@ void freeAperDecodingOfRicServiceUpdateAck(RICserviceUpdateAcknowledge_t *ricSer void procRicServiceUpdateAck(E2AP_PDU_t *e2apMsg) { - uint8_t arrIdx =0, transId =0; + uint8_t arrIdx =0; + uint16_t transId =0; uint16_t id =0, tmpIdx=0, ranFuncIdx=0; RicServiceUpdate serviceUpdate; RANfunctionsIDcause_List_t *rejectedList=NULL; @@ -6207,10 +6323,12 @@ void FreeRicSubsModRequired(E2AP_PDU_t *e2apMsg) * RFAILED - failure * ******************************************************************/ -uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod, \ - RicSubscription *ricSubscription) +uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod,\ + RicSubscription *ricSubscription) { - uint8_t arrIdx = 0, actionIdx = 0; + uint8_t arrIdx = 0; + CmLList *actionNode = NULLP; + ActionInfo *actionDb = NULLP; RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL; actionToBeModList->list.count = numActionsMod; @@ -6223,9 +6341,11 @@ uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *action } arrIdx = 0; - for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++) + CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode); + while(actionNode) { - if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD) + actionDb = (ActionInfo*)(actionNode->node); + if(actionDb->action == CONFIG_MOD) { DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t)); if(!actionToBeModList->list.array[arrIdx]) @@ -6240,7 +6360,7 @@ uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *action actionToBeMod->value.present = \ RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item; actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \ - ricSubscription->actionSequence[actionIdx].actionId; + actionDb->actionId; actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms; arrIdx++; @@ -6250,7 +6370,6 @@ uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *action return ROK; } #endif - /******************************************************************* * * @brief Fill Action required to be removed list @@ -6271,7 +6390,9 @@ uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *action uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \ RicSubscription *ricSubscription) { - uint8_t arrIdx = 0, actionIdx = 0; + uint8_t arrIdx = 0; + CmLList *actionNode = NULLP; + ActionInfo *actionDb = NULLP; RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL; actionToBeRmvList->list.count = numActionsRmv; @@ -6284,9 +6405,11 @@ uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionT } arrIdx = 0; - for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++) + CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode); + while(actionNode) { - if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL) + actionDb = (ActionInfo*)(actionNode->node); + if(actionDb->action == CONFIG_DEL) { DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t)); if(!actionToBeRmvList->list.array[arrIdx]) @@ -6300,11 +6423,8 @@ uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionT actionToBeRmv->criticality = CriticalityE2_reject; actionToBeRmv->value.present = \ RICaction_RequiredToBeRemoved_ItemIEs__value_PR_RICaction_RequiredToBeRemoved_Item; - actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = \ - ricSubscription->actionSequence[actionIdx].actionId; - fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, \ - ricSubscription->actionSequence[actionIdx].failureCause); - + actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = actionDb->actionId; + fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, actionDb->failureCause); arrIdx++; } } @@ -6330,7 +6450,9 @@ uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionT ******************************************************************/ uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription) { - uint8_t ieIdx = 0, elementCnt=0, actionIdx = 0; + ActionInfo * actionDb=NULLP; + CmLList *actionNode = NULLP; + uint8_t ieIdx = 0, elementCnt=0; uint8_t numActionsMod = 0, numActionsRmv = 0; RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP; RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP; @@ -6341,12 +6463,15 @@ uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsMod #endif /* Count number of Actions to be modified or deleted */ - for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++) + CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode); + while(actionNode) { - if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD) - numActionsMod++; - else if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL) - numActionsRmv++; + actionDb = (ActionInfo*)(actionNode->node); + if(actionDb->action == CONFIG_MOD) + numActionsMod++; + else if(actionDb->action == CONFIG_DEL) + numActionsRmv++; + actionNode = actionNode->next; } /* Count number of IEs to be added to messages */ @@ -6659,6 +6784,7 @@ void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg) RicRequestId ricReqId; RanFunction *ranFuncDb = NULLP; CmLList *ricSubsNode = NULLP; + CmLList *actionNode= NULLP; RicSubscription *ricSubsDb = NULLP; ActionInfo *actionDb = NULLP; @@ -6758,7 +6884,7 @@ void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg) modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx]; actionId = modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID; - actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb); + actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN); if(!actionDb) { DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId); @@ -6781,7 +6907,7 @@ void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg) { modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx]; actionId = modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID; - actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb); + actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN); if(!actionDb) { DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId); @@ -6806,16 +6932,16 @@ void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg) { rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx]; actionId = rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID; - actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb); + actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN); if(!actionDb) { DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId); } else { - deleteActionSequence(actionDb); + cmLListDelFrm(&ricSubsDb->actionSequence, actionNode); + deleteActionSequence(actionNode); actionDb =NULLP; - ricSubsDb->numOfActions--; /* Further handling can include : * Deletion of this action from all DU layers */ @@ -6832,7 +6958,7 @@ void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg) { rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx]; actionId = rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID; - actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb); + actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode, CONFIG_UNKNOWN); if(!actionDb) { DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId); @@ -6920,7 +7046,7 @@ void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg) * RFAILED - failure * * ****************************************************************/ -uint8_t BuildAndSendResetResponse(uint8_t transId) +uint8_t BuildAndSendResetResponse(uint16_t transId) { uint8_t ieIdx = 0, elementCnt = 0; uint8_t ret = RFAILED; @@ -7066,8 +7192,9 @@ void freeAperDecodingOfE2ResetReq(ResetRequestE2_t *resetReq) void procE2ResetRequest(E2AP_PDU_t *e2apMsg) { + uint8_t arrIdx =0; + uint16_t transId =0; uint16_t ranFuncIdx=0; - uint8_t arrIdx =0, transId =0; ResetRequestE2_t *resetReq; DU_LOG("\nINFO --> E2AP : E2 Reset request received"); @@ -7639,6 +7766,7 @@ uint8_t BuildAndSendRicSubscriptionDeleteFailure(uint16_t ranFuncId, RicRequest ricSubsDelFailureIe->value.choice.RANfunctionID = ranFuncId; ieIdx++; + ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx]; ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_CauseE2; ricSubsDelFailureIe->criticality = CriticalityE2_ignore; ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_CauseE2; @@ -7973,7 +8101,7 @@ void procRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg) break; } - if(BuildAndSendStatsDeleteReq(ricSubsDb) != ROK) + if(BuildAndSendStatsDeleteReq(ricSubsDb, true) != ROK) { DU_LOG("\nERROR --> E2AP : Failed to build and send ric subscription delete req to du layers"); } @@ -8275,8 +8403,9 @@ void FreeRemovalRequest(E2AP_PDU_t *e2apMsg) uint8_t BuildAndSendRemovalRequest() { - uint8_t ieIdx = 0, elementCnt = 0, transId = 0; + uint16_t transId = 0; uint8_t ret = RFAILED; + uint8_t ieIdx = 0, elementCnt = 0; E2AP_PDU_t *e2apMsg = NULLP; E2RemovalRequest_t *removalReq = NULLP; asn_enc_rval_t encRetVal; /* Encoder return value */ @@ -8433,7 +8562,8 @@ void freeAperDecodingOfE2RemovalFailure(E2RemovalFailure_t *removalFailure) * ****************************************************************/ void ProcE2RemovalFailure(E2AP_PDU_t *e2apMsg) { - uint8_t ieIdx = 0, transId=0; + uint8_t ieIdx = 0; + uint16_t transId=0; CauseE2_t *cause = NULLP; E2RemovalFailure_t *e2RemovalFailure=NULLP; @@ -8536,7 +8666,8 @@ void ProcE2RemovalFailure(E2AP_PDU_t *e2apMsg) void ProcE2RemovalResponse(E2AP_PDU_t *e2apMsg) { - uint8_t ieIdx = 0, transId=0; + uint8_t ieIdx = 0; + uint16_t transId=0; E2RemovalResponse_t *removalRsp = NULLP; removalRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse; @@ -9359,7 +9490,8 @@ void handleE2ConnectionRemoval(E2connectionUpdateRemove_List_t *connectionRemova void procE2ConnectionUpdate(E2AP_PDU_t *e2apMsg) { - uint8_t arrIdx =0, transId =0; + uint8_t arrIdx =0; + uint16_t transId =0; bool invalidTransId = false, connectionFailedToUpdate=false; E2FailureCause failureCause; E2ConnectionList connectionInfoList; @@ -9436,135 +9568,1615 @@ void procE2ConnectionUpdate(E2AP_PDU_t *e2apMsg) /******************************************************************* * - * @brief Handles received E2AP message and sends back response + * @brief Free RIC Subscription action to be added list * * @details * - * Function : E2APMsgHdlr + * Function : freeAperDecodingOfRicSubsActionToBeAdded * - * Functionality: - * - Decodes received E2AP control message - * - Prepares response message, encodes and sends to SCTP + * Functionality: Free the RIC Subscription action to be added list * - * @params[in] - * @return ROK - success - * RFAILED - failure + * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails + * @return void * * ****************************************************************/ -void E2APMsgHdlr(Buffer *mBuf) +void freeAperDecodingOfRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails) { - int i =0; - char *recvBuf = NULLP; - MsgLen copyCnt =0; - MsgLen recvBufLen =0; - E2AP_PDU_t *e2apMsg = NULLP; - asn_dec_rval_t rval ={0}; /* Decoder return value */ - E2AP_PDU_t e2apasnmsg={0} ; - - DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer"); - ODU_PRINT_MSG(mBuf, 0,0); - - /* Copy mBuf into char array to decode it */ - ODU_GET_MSG_LEN(mBuf, &recvBufLen); - DU_ALLOC(recvBuf, (Size)recvBufLen); + uint8_t elementIdx = 0; + RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP; - if(recvBuf == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation failed"); - return; - } - if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK) + if(subsDetails->list.array) { - DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt); - return; + for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++) + { + if(subsDetails->list.array[elementIdx]) + { + addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx]; + free(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf); + free(subsDetails->list.array[elementIdx]); + } + } + free(subsDetails->list.array); } +} -#ifdef DEBUG_ASN_PRINT - printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : "); - for(i=0; i< recvBufLen; i++) +/******************************************************************* + * + * @brief Deallocation of memory allocated by aper decoder for + * RIC Subscription action to be removed list + * + * @details + * + * Function : freeAperDecodingOfRicSubsActionToBeRemoved + * + * Functionality: Free the RIC Subscription action to be removed list + * + * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails + * @return void + * + * ****************************************************************/ +void freeAperDecodingOfRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails) +{ + uint8_t elementIdx = 0; + + if(subsDetails->list.array) { - printf("%x",recvBuf[i]); + for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++) + { + if(subsDetails->list.array[elementIdx]) + { + free(subsDetails->list.array[elementIdx]); + } + } + free(subsDetails->list.array); } -#endif - - /* Decoding flat buffer into E2AP messsage */ - e2apMsg = &e2apasnmsg; - memset(e2apMsg, 0, sizeof(E2AP_PDU_t)); +} - rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0); - DU_FREE(recvBuf, (Size)recvBufLen); +/******************************************************************* + * + * @brief Deallocation of memory allocated by aper decoder for + * RIC Subscription action to be modify + * + * @details + * + * Function : freeAperDecodingOfRicSubsActionToBeModified + * + * Functionality: Free the RIC Subscription action to be modify + * + * @params[in] RICactions_ToBeModifiedForModification_List_t List + * @return void + * + * ****************************************************************/ +void freeAperDecodingOfRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails) +{ + uint8_t elementIdx = 0; + RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP; - if(rval.code == RC_FAIL || rval.code == RC_WMORE) + if(subsDetails->list.array) { - DU_LOG("\nERROR --> E2AP : ASN decode failed"); - return; + for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++) + { + if(subsDetails->list.array[elementIdx]) + { + actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx]; + if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition) + { + free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf); + free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition); + } + free(subsDetails->list.array[elementIdx]); + } + } + free(subsDetails->list.array); } - printf("\n"); - xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); +} - switch(e2apMsg->present) +/******************************************************************* + * + * @brief Deallocation of memory allocated by aper decoder for + * RIC Subscription modification Request + * + * @details + * + * Function freeAperDecodingOfRicSubsModificationReq + * + * Functionality : Free RIC Subscription modification Request + * + * @params[in] E2AP_PDU + * @return void + * + ******************************************************************/ +void freeAperDecodingOfRicSubsModificationReq(E2AP_PDU_t *e2apRicMsg) +{ + uint8_t idx = 0; + RICsubscriptionModificationRequest_t *ricSubscriptionModReq; + RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe; + + ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest; + + if(ricSubscriptionModReq->protocolIEs.list.array) { - case E2AP_PDU_PR_unsuccessfulOutcome: + for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++) + { + if(ricSubscriptionModReq->protocolIEs.list.array[idx]) { - switch(e2apMsg->choice.unsuccessfulOutcome->value.present) + ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx]; + + switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id) { - case UnsuccessfulOutcomeE2__value_PR_E2setupFailure: - { - procE2SetupFailure(e2apMsg); - break; - } - case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure: - { - procE2NodeConfigUpdateFailure(e2apMsg); - break; - } - case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure: + case ProtocolIE_IDE2_id_RICrequestID: + break; + + case ProtocolIE_IDE2_id_RANfunctionID: + break; + + case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List: { - procRicServiceUpdateFailure(e2apMsg); + freeAperDecodingOfRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List)); break; } - case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse: + case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List: { - procRicSubscriptionModificationRefuse(e2apMsg); + freeAperDecodingOfRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List)); break; } - case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure: + case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List: { - ProcE2RemovalFailure(e2apMsg); + freeAperDecodingOfRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List)); break; } default: { - DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\ - e2apMsg->choice.unsuccessfulOutcome->value.present); - return; + DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id); + break; } + } - free(e2apMsg->choice.unsuccessfulOutcome); - break; + + free(ricSubscriptionModReq->protocolIEs.list.array[idx]); } - case E2AP_PDU_PR_successfulOutcome: - { - switch(e2apMsg->choice.successfulOutcome->value.present) - { - case SuccessfulOutcomeE2__value_PR_E2setupResponse: - { - if(!duCb.e2Status) - { - procE2SetupRsp(e2apMsg); - } - break; - } - case SuccessfulOutcomeE2__value_PR_ResetResponseE2: - { - procResetResponse(e2apMsg); - break; - } - case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge: - { - procRicServiceUpdateAck(e2apMsg); - break; - } + } + free(ricSubscriptionModReq->protocolIEs.list.array); + } +} +/******************************************************************* + * + * @brief Extract RIC Action to be added + * + * @details + * + * Function : extractRicActionToBeAddedForModification + * + * Functionality : This function : + * - [Step -1] Traverse each AddedForModification item indexes. + * - [Step -2] Add each action id related information in + * RicSubscription Db. + * - [Step -3] If failed to store then add action related info in + * pending rsp's rejectedActionList. + * - [Step -4] Else increment action added count + * - [Step -5] If there is even 1 action that can be added, + * return ROK, else RFAILED. + * + * @params[in] RAN Function Database structure + * RIC Subscription Info to be added to RAN function + * RIC Action To Be AddedForModification List received from RIC + * failure Cause + * Pending Subs Mod Rsp Info + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t extractRicActionToBeAddedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \ + RICactions_ToBeAddedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp) +{ + uint8_t actionAdded=0; + CmLList *actionNode = NULLP; + uint8_t actionIdx = 0; + uint8_t ricActionId = 0; + RICaction_ToBeAddedForModification_ItemIEs_t *actionItem = NULLP; + + if(actionList->list.array) + { + for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++) + { + /* Step -1 */ + actionItem =(RICaction_ToBeAddedForModification_ItemIEs_t *)actionList->list.array[actionIdx]; + switch(actionItem->id) + { + case ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item: + { + /* Step -2 */ + actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeAddedForModification_Item,\ + &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item, failureCause); + + if(!actionNode) + { + /* Step -3 */ + subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].id = ricActionId; + if(failureCause->causeType == E2_NOTHING) + { + failureCause->causeType = E2_RIC_REQUEST; + failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE; + } + memcpy(&subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].failureCause, \ + failureCause, sizeof(E2FailureCause)); + subsModRsp->addActionStatus.numOfRejectedActions++; + } + else + { + /* Step -4 */ + actionAdded++; + } + break; + } + default: + DU_LOG("\nERROR --> E2AP : Invalid IE received in RicAddedForModificationLst:%ld",actionItem->id); + break; + } + } + } + + /* Step -5 */ + if(actionAdded) + return ROK; + + if(failureCause->causeType == E2_NOTHING) + { + failureCause->causeType = E2_RIC_REQUEST; + failureCause->cause = E2_ACTION_NOT_SUPPORTED; + } + return RFAILED; +} + +/******************************************************************* + * + * @brief Extract RIC Action to be Modified + * + * @details + * + * Function : extractRicActionToBeModifiedForModification + * + * Functionality : This function : + * - [Step -1] Traverse each Modification item indexes. + * - [Step -2] Find each action id related information in + * RicSubscription Db. + * - [Step -3] If not found store the action related info in pending + * rsp's action rejected. + * - [Step -4] If found store the new node in action seq list. + * [Step -4.1] If action failed to store, add the action + * info in pending subscription rsp's rejected list. + * [Step -4.2] If action stored successfully, change the status + * of added action to modified because action added as part of + * ric subscription modification req. + * - [Step -5] If there is even 1 action that can be modified, + * return ROK, else RFAILED. + * + * @params[in] RAN Function Database structure + * RIC Subscription Info to be Modified to RAN function + * RIC Action To Be ModifiedForModification List received from RIC + * failure Cause + * Pending Subs Mod Rsp Info + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t extractRicActionToBeModifiedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \ + RICactions_ToBeModifiedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp) +{ + uint8_t actionId=0; + uint8_t actionIdx = 0; + uint8_t actionFound=0; + CmLList *actionNode = NULLP; + ActionInfo *actionDb = NULLP; + RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP; + + if(actionList->list.array) + { + for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++) + { + /* [Step -1] */ + actionItem =(RICaction_ToBeModifiedForModification_ItemIEs_t *)actionList->list.array[actionIdx]; + switch(actionItem->id) + { + case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item: + { + /* [Step -2] */ + actionId=actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID; + actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN); + if(!actionNode) + { + /* [Step -3] */ + subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionDb->actionId; + failureCause->causeType = E2_RIC_REQUEST; + failureCause->cause = E2_ACTION_NOT_SUPPORTED; + memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \ + failureCause, sizeof(E2FailureCause)); + subsModRsp->modActionStatus.numOfRejectedActions++; + } + else + { + /* [Step -4] */ + actionNode = NULLP; + actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeModifiedForModification_Item,\ + &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item, failureCause); + + if(!actionNode) + { + /* [Step -4.1] */ + subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionId; + if(failureCause->causeType == E2_NOTHING) + { + failureCause->causeType = E2_RIC_REQUEST; + failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE; + } + memcpy(&subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \ + failureCause, sizeof(E2FailureCause)); + subsModRsp->addActionStatus.numOfRejectedActions++; + } + else + { + /* [Step -4.2] */ + actionDb = (ActionInfo*)actionNode->node; + actionDb->action=CONFIG_MOD; + actionFound++; + } + break; + } + break; + } + default: + DU_LOG("\nERROR --> E2AP : Invalid IE received in RicModifiedForModificationLst:%ld",actionItem->id); + break; + } + } + } + + /* [Step -5] */ + if(actionFound) + return ROK; + + return RFAILED; +} + +/******************************************************************* + * + * @brief Extract RIC Action to be Removed + * + * @details + * + * Function : extractRicActionToBeRemovedForModification + * + * Functionality : This function : + * - [Step -1] Traverse each RemovedForModification item indexes. + * - [Step -2] Find each action id related information in + * RicSubscription Db. + * - [Step -3] If not found store the action related info in pending + * rsp's rejectedActionList. + * - [Step -4] If found mark action's status CONFIG_DEL. + * - [Step -5] If there is even 1 action that can be Removed, + * return ROK, else RFAILED. + * + * @params[in] RAN Function Database structure + * RIC Subscription Info to be Removed to RAN function + * RIC Action To Be RemovedForModification List received from RIC + * failure Cause + * Pending ric subs mod Rsp Info to store failure result + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t extractRicActionToBeRemovedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \ + RICactions_ToBeRemovedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp) +{ + uint8_t actionId=0; + uint8_t actionIdx = 0; + uint8_t actionFound=0; + CmLList *actionNode = NULLP; + ActionInfo *actionDb = NULLP; + RICaction_ToBeRemovedForModification_ItemIEs_t *actionItem = NULLP; + + if(actionList->list.array) + { + for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++) + { + /* [Step -1] */ + actionItem =(RICaction_ToBeRemovedForModification_ItemIEs_t *)actionList->list.array[actionIdx]; + switch(actionItem->id) + { + case ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item: + { + /* [Step -2] */ + actionId = actionItem->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID; + actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN); + if(!actionNode) + { + /* [Step -3] */ + subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].id = actionDb->actionId; + if(failureCause->causeType == E2_NOTHING) + { + failureCause->causeType = E2_RIC_REQUEST; + failureCause->cause = E2_ACTION_NOT_SUPPORTED; + } + memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].failureCause, \ + failureCause, sizeof(E2FailureCause)); + subsModRsp->removeActionStatus.numOfRejectedActions++; + } + else + { + /* [Step -4] */ + actionDb->action=CONFIG_DEL; + actionFound++; + } + break; + } + default: + DU_LOG("\nERROR --> E2AP : Invalid IE received in RicRemovedForModificationLst:%ld",actionItem->id); + break; + } + } + } + + /* [Step -5] */ + if(actionFound) + return ROK; + + return RFAILED; +} + +/******************************************************************* + * + * @brief Process RIC Subscription modification request + * + * @details + * + * Function : procRicSubscriptionModificationRequest + * + * Functionality: Process RIC subscription modification request. + * + * @params[in] E2AP PDU + * @return void + * + ******************************************************************/ +void procRicSubscriptionModificationRequest(E2AP_PDU_t *e2apMsg) +{ + uint8_t ieIdx = 0; + uint16_t ranFuncId = 0; + RicRequestId ricReqId; + E2FailureCause failureCause; + bool procFailure = false; + bool addActionIeProcessed=false; + bool modActionIeProcessed =false; + bool removeActionIeProcessed =false; + CmLList *ricSubsNode = NULLP; + RanFunction *ranFuncDb = NULLP; + RicSubscription *ricSubsDb = NULLP; + RICsubscriptionModificationRequest_t *ricSubsModifyReq = NULLP; + RICsubscriptionModificationRequest_IEs_t *ricSubsModifyReqIe = NULLP; + + DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Request", __func__); + + do{ + if(!e2apMsg) + { + DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__); + break; + } + + if(!e2apMsg->choice.initiatingMessage) + { + DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__); + break; + } + + ricSubsModifyReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest; + for(ieIdx = 0; ieIdx < ricSubsModifyReq->protocolIEs.list.count; ieIdx++) + { + if(!ricSubsModifyReq->protocolIEs.list.array[ieIdx]) + { + DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx); + break; + } + + ricSubsModifyReqIe = ricSubsModifyReq->protocolIEs.list.array[ieIdx]; + switch(ricSubsModifyReqIe->id) + { + case ProtocolIE_IDE2_id_RICrequestID: + { + memset(&ricReqId, 0, sizeof(RicRequestId)); + ricReqId.requestorId = ricSubsModifyReqIe->value.choice.RICrequestID.ricRequestorID; + ricReqId.instanceId = ricSubsModifyReqIe->value.choice.RICrequestID.ricInstanceID; + break; + } + + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsModifyReqIe->value.choice.RANfunctionID; + ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId); + if(!ranFuncDb) + { + DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId); + procFailure = true; + break; + } + + ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode); + if(!ricSubsDb) + { + DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\ + __func__, ricReqId.requestorId, ricReqId.instanceId); + procFailure = true; + break; + } + memset(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp], 0, sizeof(PendingSubsModRspInfo)); + memcpy(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].requestId, + &ricReqId, sizeof(RicRequestId)); + ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].ranFuncId = ranFuncId; + + break; + } + case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List: + { + if(extractRicActionToBeRemovedForModification(ranFuncDb, ricSubsDb,\ + &ricSubsModifyReqIe->value.choice.RICactions_ToBeRemovedForModification_List,\ + &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK) + { + removeActionIeProcessed= true; + } + + break; + } + case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List: + { + if(extractRicActionToBeModifiedForModification(ranFuncDb, ricSubsDb,\ + &ricSubsModifyReqIe->value.choice.RICactions_ToBeModifiedForModification_List,\ + &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK) + { + modActionIeProcessed = true; + } + break; + } + case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List: + { + if(extractRicActionToBeAddedForModification(ranFuncDb, ricSubsDb,\ + &ricSubsModifyReqIe->value.choice.RICactions_ToBeAddedForModification_List,\ + &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK) + { + addActionIeProcessed = true; + } + break; + } + default: + break; + } /* End of switch for Protocol IE Id */ + + if(procFailure) + break; + } /* End of for loop for Protocol IE list */ + + break; + }while(true); + + if(!removeActionIeProcessed && !addActionIeProcessed && !modActionIeProcessed) + { + BuildAndSendRicSubscriptionModificationFailure(ranFuncId, ricReqId, failureCause); + } + 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++; + + /*If the remove-action ie is present, send a stats delete request; + * otherwise, change removeActionCompleted to true in the pendingSubsModRspInfo. */ + if(removeActionIeProcessed) + { + BuildAndSendStatsDeleteReq(ricSubsDb, false); + } + else + { + ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].removeActionCompleted = true; + } + + /*If the mod-action ie is present, send a stats modification request; + * otherwise, change modActionCompleted to true in the pendingSubsModRspInfo. */ + if(modActionIeProcessed) + { + BuildAndSendStatsModificationReq(ricSubsDb); + } + else + { + ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].modActionCompleted= true; + } + + /*If the add-action ie is present, send a stats add request; + * otherwise, change addActionCompleted to true in the pendingSubsModRspInfo. */ + if(addActionIeProcessed) + { + BuildAndSendStatsReq(ricSubsDb); + } + else + { + ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].addActionCompleted= true; + } + + } + + freeAperDecodingOfRicSubsModificationReq(e2apMsg); +} + +/******************************************************************* + * @brief Free RIC Subscription Modification Failure Message + * + * @details + * + * Function : FreeRicSubscriptionModificationFailure + * + * Functionality: Free RIC Subscription Modification Failure + * + * @param E2AP Message PDU + * @return void + * + ******************************************************************/ +void FreeRicSubscriptionModificationFailure(E2AP_PDU_t *e2apMsg) +{ + uint8_t ieIdx = 0; + RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP; + + if(e2apMsg) + { + if(e2apMsg->choice.unsuccessfulOutcome) + { + ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure; + if(ricSubsModFailure->protocolIEs.list.array) + { + for(ieIdx = 0; ieIdx < ricSubsModFailure->protocolIEs.list.count; ieIdx++) + { + DU_FREE(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t)); + } + DU_FREE(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size); + } + DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t)); + } + DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));; + } +} +/******************************************************************* + * + * @brief Builds and Send RIC Subscription Modification Failure + * + * @details + * + * Function : BuildAndSendRicSubscriptionModificationFailure + * + * Functionality: Build and send RIC Subscription Modification Failure. + * + * @params[in] + * Ran Func Id + * Ric Req Id + * E2 failure cause + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t BuildAndSendRicSubscriptionModificationFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause) +{ + uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED; + E2AP_PDU_t *e2apMsg = NULLP; + RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP; + RICsubscriptionModificationFailure_IEs_t *ricSubsModFailureIe = NULLP; + asn_enc_rval_t encRetVal; /* Encoder return value */ + + while(true) + { + DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Failure 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_unsuccessfulOutcome; + DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t)); + if(e2apMsg->choice.unsuccessfulOutcome == NULLP) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__); + break; + } + e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification; + e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject; + e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure; + + + ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure; + + elementCnt = 3; + ricSubsModFailure->protocolIEs.list.count = elementCnt; + ricSubsModFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationFailure_IEs_t *); + + DU_ALLOC(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size); + if(ricSubsModFailure->protocolIEs.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__); + break; + } + + for(ieIdx = 0; ieIdx < elementCnt; ieIdx++) + { + DU_ALLOC(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t)); + if(ricSubsModFailure->protocolIEs.list.array[ieIdx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \ + __func__, ieIdx, __LINE__); + break; + } + } + if(ieIdx < elementCnt) + break; + + ieIdx = 0; + ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx]; + ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RICrequestID; + ricSubsModFailureIe->criticality = CriticalityE2_reject; + ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RICrequestID; + ricSubsModFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId; + ricSubsModFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId; + + ieIdx++; + ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx]; + ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID; + ricSubsModFailureIe->criticality = CriticalityE2_reject; + ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RANfunctionID; + ricSubsModFailureIe->value.choice.RANfunctionID = ranFuncId; + + ieIdx++; + ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx]; + ricSubsModFailureIe->id = ProtocolIE_IDE2_id_CauseE2; + ricSubsModFailureIe->criticality = CriticalityE2_reject; + ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_CauseE2; + fillE2Cause(&ricSubsModFailureIe->value.choice.CauseE2, failureCause); + + /* 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 Failure 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 Failure 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 Failure Message"); + break; + } + + ret = ROK; + break; + } + + FreeRicSubscriptionModificationFailure(e2apMsg); + 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 + * + * @details + * + * Function : E2APMsgHdlr + * + * Functionality: + * - Decodes received E2AP control message + * - Prepares response message, encodes and sends to SCTP + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void E2APMsgHdlr(Buffer *mBuf) +{ + int i =0; + char *recvBuf = NULLP; + MsgLen copyCnt =0; + MsgLen recvBufLen =0; + E2AP_PDU_t *e2apMsg = NULLP; + asn_dec_rval_t rval ={0}; /* Decoder return value */ + E2AP_PDU_t e2apasnmsg={0} ; + + DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer"); + ODU_PRINT_MSG(mBuf, 0,0); + + /* Copy mBuf into char array to decode it */ + ODU_GET_MSG_LEN(mBuf, &recvBufLen); + DU_ALLOC(recvBuf, (Size)recvBufLen); + + if(recvBuf == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed"); + return; + } + if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt); + return; + } + +#ifdef DEBUG_ASN_PRINT + printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : "); + for(i=0; i< recvBufLen; i++) + { + printf("%x",recvBuf[i]); + } +#endif + + /* Decoding flat buffer into E2AP messsage */ + e2apMsg = &e2apasnmsg; + memset(e2apMsg, 0, sizeof(E2AP_PDU_t)); + + rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0); + DU_FREE(recvBuf, (Size)recvBufLen); + + if(rval.code == RC_FAIL || rval.code == RC_WMORE) + { + DU_LOG("\nERROR --> E2AP : ASN decode failed"); + return; + } + printf("\n"); + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); + + switch(e2apMsg->present) + { + case E2AP_PDU_PR_unsuccessfulOutcome: + { + switch(e2apMsg->choice.unsuccessfulOutcome->value.present) + { + case UnsuccessfulOutcomeE2__value_PR_E2setupFailure: + { + procE2SetupFailure(e2apMsg); + break; + } + case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure: + { + procE2NodeConfigUpdateFailure(e2apMsg); + break; + } + case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure: + { + procRicServiceUpdateFailure(e2apMsg); + break; + } + case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse: + { + procRicSubscriptionModificationRefuse(e2apMsg); + break; + } + case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure: + { + ProcE2RemovalFailure(e2apMsg); + break; + } + default: + { + DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\ + e2apMsg->choice.unsuccessfulOutcome->value.present); + return; + } + } + free(e2apMsg->choice.unsuccessfulOutcome); + break; + } + case E2AP_PDU_PR_successfulOutcome: + { + switch(e2apMsg->choice.successfulOutcome->value.present) + { + case SuccessfulOutcomeE2__value_PR_E2setupResponse: + { + if(!duCb.e2Status) + { + procE2SetupRsp(e2apMsg); + } + break; + } + case SuccessfulOutcomeE2__value_PR_ResetResponseE2: + { + procResetResponse(e2apMsg); + break; + } + case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge: + { + procRicServiceUpdateAck(e2apMsg); + break; + } case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm: { procRicSubscriptionModificationConfirm(e2apMsg); @@ -9634,6 +11246,12 @@ void E2APMsgHdlr(Buffer *mBuf) procE2ConnectionUpdate(e2apMsg); break; } + case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest: + { + DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Request received"); + procRicSubscriptionModificationRequest(e2apMsg); + break; + } default: { DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\