From: lal.harshita Date: Tue, 3 Oct 2023 10:21:16 +0000 (+0530) Subject: [Epic-ID: ODUHIGH-516][Task-ID: ODUHIGH-531] RIC Subscription Modification Required X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=commitdiff_plain;h=55fc3c14a0c74c8c3d3dfec9e843776e7891f2de;p=o-du%2Fl2.git [Epic-ID: ODUHIGH-516][Task-ID: ODUHIGH-531] RIC Subscription Modification Required Change-Id: I08f26f366676f4ff2723d71d38bae90bfcdd0edb Signed-off-by: lal.harshita --- diff --git a/src/du_app/du_e2ap_mgr.h b/src/du_app/du_e2ap_mgr.h index c018f5709..ef32be42d 100644 --- a/src/du_app/du_e2ap_mgr.h +++ b/src/du_app/du_e2ap_mgr.h @@ -391,6 +391,7 @@ typedef struct ActionType type; ActionDefinition definition; ConfigType action; + E2FailureCause failureCause; /* Used only when an action is required to be deleted */ }ActionInfo; /* O-RAN.WG3.E2AP-R003-v03.00 : Section 9.1.1.1 : maxofRICActionID */ diff --git a/src/du_app/du_e2ap_msg_hdl.c b/src/du_app/du_e2ap_msg_hdl.c index bef81af0e..291fbe52c 100644 --- a/src/du_app/du_e2ap_msg_hdl.c +++ b/src/du_app/du_e2ap_msg_hdl.c @@ -5553,6 +5553,413 @@ uint8_t duSendE2NodeConfigurationUpdate() } return ROK; } + +/******************************************************************* + * + * @brief Free RIC Subscription Modification Required + * + * @details + * + * Function : FreeRicSubsModRequired + * + * Functionality: Freqq RIC Subscription Modification required + * + * @param E2AP Message PDU to be freed + * @return void + * + ******************************************************************/ +void FreeRicSubsModRequired(E2AP_PDU_t *e2apMsg) +{ + uint8_t ieIdx = 0, arrIdx = 0; + RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP; + RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP; + RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP; + RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP; + + if(e2apMsg) + { + if(e2apMsg->choice.initiatingMessage) + { + ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired; + if(ricSubsModReqd->protocolIEs.list.array) + { + for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++) + { + if(ricSubsModReqd->protocolIEs.list.array[ieIdx]) + { + ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx]; + switch(ricSubsModReqdIe->id) + { + case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List: + { + actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List; + if(actionToBeModList->list.array) + { + for(arrIdx = 0; arrIdx < actionToBeModList->list.count; arrIdx++) + { + DU_FREE(actionToBeModList->list.array[arrIdx], \ + sizeof(RICaction_RequiredToBeModified_ItemIEs_t)); + } + DU_FREE(actionToBeModList->list.array, actionToBeModList->list.size); + } + break; + } + + case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List: + { + actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List; + if(actionToBeRmvList->list.array) + { + for(arrIdx = 0; arrIdx < actionToBeRmvList->list.count; arrIdx++) + { + DU_FREE(actionToBeRmvList->list.array[arrIdx], \ + sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t)); + } + DU_FREE(actionToBeRmvList->list.array, actionToBeRmvList->list.size); + } + break; + } + + default: + break; + } + DU_FREE(ricSubsModReqd->protocolIEs.list.array[ieIdx], \ + sizeof(RICsubscriptionModificationRequired_IEs_t)); + } + } + DU_FREE(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size); + } + DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + } + DU_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* + * + * @brief Fill Action required to be modified list + * + * @details + * + * Function : FillActionReqdToBeModList + * + * Functionality: Fill Action required to be modified list + * + * @param RIC Actions Required To Be Modified List to be filled + * Number of actions to be modified + * RIC Subscription DB + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod, \ + RicSubscription *ricSubscription) +{ + uint8_t arrIdx = 0, actionIdx = 0; + RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL; + + actionToBeModList->list.count = numActionsMod; + actionToBeModList->list.size = numActionsMod * sizeof(RICaction_RequiredToBeModified_ItemIEs_t *); + DU_ALLOC(actionToBeModList->list.array, actionToBeModList->list.size); + if(!actionToBeModList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__); + return RFAILED; + } + + arrIdx = 0; + for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++) + { + if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD) + { + DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t)); + if(!actionToBeModList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__); + return RFAILED; + } + actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[arrIdx]; + + actionToBeMod->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeModified_Item; + actionToBeMod->criticality = CriticalityE2_reject; + actionToBeMod->value.present = \ + RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item; + actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \ + ricSubscription->actionSequence[actionIdx].actionId; + actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms; + + arrIdx++; + } + } + + return ROK; +} + +/******************************************************************* + * + * @brief Fill Action required to be removed list + * + * @details + * + * Function : FillActionReqdToBeRmvList + * + * Functionality: Fill Action required to be removed list + * + * @param RIC Actions Required To Be Removed List to be filled + * Number of actions to be removed + * RIC Subscription DB + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \ + RicSubscription *ricSubscription) +{ + uint8_t arrIdx = 0, actionIdx = 0; + RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL; + + actionToBeRmvList->list.count = numActionsRmv; + actionToBeRmvList->list.size = numActionsRmv * sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t *); + DU_ALLOC(actionToBeRmvList->list.array, actionToBeRmvList->list.size); + if(!actionToBeRmvList->list.array) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__); + return RFAILED; + } + + arrIdx = 0; + for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++) + { + if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL) + { + DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t)); + if(!actionToBeRmvList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__); + return RFAILED; + } + actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[arrIdx]; + + actionToBeRmv->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeRemoved_Item; + 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); + + arrIdx++; + } + } + + return ROK; +} + +/******************************************************************* + * + * @brief Fill RIC Subscription Modification Required IEs + * + * @details + * + * Function : FillRicSubsModRequired + * + * Functionality: Fill RIC Subscription Modification Required IEs + * + * @param RIC Subscription Modification Required IEs to be filled + * RIC Subscription DB + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription) +{ + uint8_t ieIdx = 0, elementCnt=0, actionIdx = 0; + uint8_t numActionsMod = 0, numActionsRmv = 0; + RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP; + RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP; + RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP; + + /* Count number of Actions to be modified or deleted */ + for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++) + { + if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD) + numActionsMod++; + else if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL) + numActionsRmv++; + } + + /* Count number of IEs to be added to messages */ + elementCnt = 2; + if(numActionsMod) + elementCnt++; + if(numActionsRmv) + elementCnt++; + + ricSubsModReqd->protocolIEs.list.count = elementCnt; + ricSubsModReqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequired_IEs_t *); + DU_ALLOC(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size); + if(!ricSubsModReqd->protocolIEs.list.array) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__); + return RFAILED; + } + + for(ieIdx = 0; ieIdx < elementCnt; ieIdx++) + { + DU_ALLOC(ricSubsModReqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRequired_IEs_t)); + if(!ricSubsModReqd->protocolIEs.list.array[ieIdx]) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__); + return RFAILED; + } + } + + /* RIC Request ID */ + ieIdx = 0; + ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx]; + ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICrequestID; + ricSubsModReqdIe->criticality = CriticalityE2_reject; + ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RICrequestID; + ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID = ricSubscription->requestId.requestorId; + ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID = ricSubscription->requestId.instanceId; + + /* RAN Function ID */ + ieIdx++; + ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx]; + ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RANfunctionID; + ricSubsModReqdIe->criticality = CriticalityE2_reject; + ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RANfunctionID; + ricSubsModReqdIe->value.choice.RANfunctionID = ricSubscription->ranFuncId; + + /* RIC Actions Required to be Modified */ + if(numActionsMod) + { + ieIdx++; + ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx]; + ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List; + ricSubsModReqdIe->criticality = CriticalityE2_reject; + ricSubsModReqdIe->value.present = \ + RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeModified_List; + actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List; + + if(FillActionReqdToBeModList(actionToBeModList, numActionsMod, ricSubscription) != ROK) + { + DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__); + return RFAILED; + } + } + + /* RIC Actions Required to be removed */ + if(numActionsRmv) + { + ieIdx++; + ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx]; + ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List; + ricSubsModReqdIe->criticality = CriticalityE2_reject; + ricSubsModReqdIe->value.present = \ + RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeRemoved_List; + actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List; + + if(FillActionReqdToBeRmvList(actionToBeRmvList, numActionsRmv, ricSubscription) != ROK) + { + DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__); + return RFAILED; + } + } + + return ROK; +} + +/******************************************************************* + * + * @brief Builds and Send RIC Subscription Modification Required + * message + * + * @details + * + * Function : BuildAndSendRicSubsModRequired + * + * Functionality: Builds and Send RIC Subscription Modification + * Required message + * + * @param RIC Subscription DB + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t BuildAndSendRicSubsModRequired(RicSubscription *ricSubscription) +{ + uint8_t ret = RFAILED; + E2AP_PDU_t *e2apMsg = NULLP; + RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP; + asn_enc_rval_t encRetVal; /* Encoder return value */ + + DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Required \n"); + while(true) + { + DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); + if(e2apMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__); + break; + } + + e2apMsg->present = E2AP_PDU_PR_initiatingMessage; + DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + if(e2apMsg->choice.initiatingMessage == NULLP) + { + DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__); + break; + } + e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; + e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired; + e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired; + + ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired; + + if(FillRicSubsModRequired(ricSubsModReqd, ricSubscription) != ROK) + { + DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__); + break; + } + + /* Encode */ + 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 Modifiction Required structure (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 Required \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 : Sending RIC Subscription Modification Required failed"); + } + + ret = ROK; + break; + } + + /* Free RIC Subscription modification required */ + FreeRicSubsModRequired(e2apMsg); + return ret; +} + /******************************************************************* * * @brief Handles received E2AP message and sends back response diff --git a/src/ric_stub/ric_e2ap_msg_hdl.c b/src/ric_stub/ric_e2ap_msg_hdl.c index 0ee331cc7..209449847 100644 --- a/src/ric_stub/ric_e2ap_msg_hdl.c +++ b/src/ric_stub/ric_e2ap_msg_hdl.c @@ -125,6 +125,108 @@ uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId) return ROK; } /* SendE2APMsg */ +/******************************************************************* + * + * @brief Fetches RAN Function DB + * + * @details + * + * Function : fetchRanFuncFromRanFuncId + * + * Functionality: Fetches RAN function DB from E2AP DB using + * RAN function ID + * + * @params[in] RAN Function ID + * @return RAN Function DB + * NULL, in case of failure + * + * ****************************************************************/ +RanFunction *fetchRanFuncFromRanFuncId(DuDb *duDb, uint16_t ranFuncId) +{ + RanFunction *ranFuncDb = NULLP; + + /* Fetch RAN Function DB */ + if(duDb->ranFunction[ranFuncId-1].id == ranFuncId) + { + ranFuncDb = &duDb->ranFunction[ranFuncId-1]; + } + else + { + DU_LOG("\nERROR --> DU_APP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId); + } + + return ranFuncDb; +} + +/******************************************************************* + * + * @brief Fetch subscripton DB + * + * @details + * + * Function : fetchSubsInfoFromRicReqId + * + * Functionality: Fetches subscription DB from RAN Function DB + * using RIC Request ID + * + * @params[in] RIC Request ID + * RAN Function DB + * Pointer to RIC Subscription node to be searched + * @return RIC Subscription from RAN Function's subcription list + * NULL, in case of failure + * + * ****************************************************************/ +RicSubscription *fetchSubsInfoFromRicReqId(RicRequestId ricReqId, RanFunction *ranFuncDb) +{ + uint8_t subsIdx = 0; + RicSubscription *ricSubscriptionInfo = NULLP; + + for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++) + { + if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) && + (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId)) + { + ricSubscriptionInfo = &ranFuncDb->subscriptionList[subsIdx]; + break; + } + } + return ricSubscriptionInfo; +} + +/******************************************************************* + * + * @brief Fetch Action details + * + * @details + * + * Function : fetchActionInfoFromActionId + * + * Functionality: Fetch action details from RIC subscription DB + * using action ID + * + * @params[in] Action ID + * RIC Subscription DB + * @return Action Info DB + * NULL, in case of failure + * + * ****************************************************************/ +ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo) +{ + ActionInfo *actionInfoDb = NULLP; + if(ricSubscriptionInfo->actionSequence[actionId].actionId == actionId) + { + actionInfoDb = &ricSubscriptionInfo->actionSequence[actionId]; + } + else + { + DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \ + subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\ + ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId); + + } + return actionInfoDb; +} + /******************************************************************* * * @brief deallocate memory allocated in E2 Node Config Update Failure @@ -310,9 +412,8 @@ uint8_t BuildAndSendE2NodeConfigUpdateFailure(uint32_t duId, uint8_t transId, ui void ProcE2NodeConfigUpdate(uint32_t duId, E2nodeConfigurationUpdate_t *e2NodeConfigUpdate) { - uint8_t ieIdx = 0, duIdx = 0; + uint8_t ieIdx = 0; uint8_t transId = 0, e2NodeUpdateListIdx=0; - DuDb *duDb = NULLP; E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList=NULLP; E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe=NULLP; E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULLP; @@ -1107,9 +1208,10 @@ uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscr actionItem->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item; /* RIC Action ID */ - actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId++; + actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId; ricSubsDb->actionSequence[ricActionId].actionId = \ actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID; + ricActionId++; /* RIC Action Type */ actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report; @@ -1476,12 +1578,14 @@ uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp) { - uint8_t duIdx = 0, ieIdx = 0,subsIdx = 0, notAdmitIdx = 0; + uint8_t duIdx = 0, ieIdx = 0, notAdmitIdx = 0; uint8_t ranFuncId = 0, actionId = 0; DuDb *duDb = NULLP; bool ricReqIdDecoded = false; RicRequestId ricReqId; RanFunction *ranFuncDb = NULLP; + RicSubscription *ricSubs = NULLP; + ActionInfo *action = NULLP; RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP; RICaction_NotAdmitted_List_t *notAdmitList = NULLP; @@ -1517,11 +1621,8 @@ void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricS case ProtocolIE_IDE2_id_RANfunctionID: { ranFuncId = ricSubsRspIe->value.choice.RANfunctionID; - if(duDb->ranFunction[ranFuncId-1].id == ranFuncId) - { - ranFuncDb = &duDb->ranFunction[ranFuncId-1]; - } - else + ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId); + if(!ranFuncDb) { DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId); return; @@ -1543,22 +1644,18 @@ void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricS actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\ value.choice.RICaction_NotAdmitted_Item.ricActionID; - /* Remove action from RAN Function's subscription list */ - for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++) + /* Remove action from RAN Function's subscription list */ + ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb); + if(ricSubs) + { + action = fetchActionInfoFromActionId(actionId, ricSubs); + if(action) { - if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) && - (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId)) - { - if(ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId].actionId == actionId) - { - memset(&ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId], 0, \ - sizeof(ActionInfo)); - ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId].actionId = -1; - ranFuncDb->subscriptionList[subsIdx].numOfActions--; - break; - } - } + memset(action, 0, sizeof(ActionInfo)); + ricSubs->actionSequence[actionId].actionId = -1; + ricSubs->numOfActions--; } + } } break; } @@ -1624,6 +1721,7 @@ void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg) uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId) { + uint8_t ret = RFAILED; E2AP_PDU_t *e2apMsg = NULL; E2setupFailure_t *e2SetupFailure; asn_enc_rval_t encRetVal; @@ -1727,10 +1825,13 @@ uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId) DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed"); break; } + + ret = ROK; break; } FreeE2SetupFailure(e2apMsg); + return ret; } /******************************************************************* @@ -1926,8 +2027,7 @@ uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId) if(e2apMsg->choice.successfulOutcome == NULLP) { DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome"); - RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); - return RFAILED; + break; } e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset; @@ -1972,7 +2072,7 @@ uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId) { DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); - return RFAILED; + break; } else { @@ -1987,7 +2087,7 @@ uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId) if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) { DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response"); - return RFAILED; + break; } ret = ROK; @@ -1995,7 +2095,7 @@ uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId) }while(true); FreeE2ResetResponse(e2apMsg); - return ROK; + return ret; } /******************************************************************* @@ -2015,9 +2115,8 @@ uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId) uint8_t ProcE2ResetReq(uint32_t duId, ResetRequestE2_t *resetReq) { - uint8_t ieIdx = 0, duIdx = 0; + uint8_t ieIdx = 0; uint8_t transId = 0, cause = 0; - DuDb *duDb = NULLP; if(resetReq) { @@ -2769,6 +2868,7 @@ void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate) int8_t transId =-1; uint8_t duIdx = 0, elementCnt =0, arrIdx = 0; uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0; + RanFunction *ranFuncDb = NULLP; RANfunction_ItemIEs_t *ranFuncItemIe =NULL; RANfunction_Item_t *ranFuncItem =NULL; RANfunctionID_Item_t *ranFuncIdItem=NULL; @@ -2856,7 +2956,7 @@ void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate) { ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx]; ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item; - if(duDb->ranFunction[ranFuncItem->ranFunctionID-1].id != ranFuncItem->ranFunctionID) + if(fetchRanFuncFromRanFuncId(duDb, ranFuncItem->ranFunctionID) == NULLP) { /* Calculating total number of ran fuctions which are not present */ failedRanFuncCount++; @@ -2892,9 +2992,10 @@ void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate) { delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx]; ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item; - if(duDb->ranFunction[ranFuncIdItem->ranFunctionID-1].id == ranFuncIdItem->ranFunctionID) + ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncIdItem->ranFunctionID); + if(ranFuncDb) { - memset(&duDb->ranFunction[ranFuncIdItem->ranFunctionID-1], 0, sizeof(RanFunction)); + memset(ranFuncDb, 0, sizeof(RanFunction)); duDb->numOfRanFunction--; } @@ -2953,9 +3054,9 @@ uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricS { uint8_t ieIdx = 0, duIdx = 0, subsIdx = 0; uint8_t ranFuncId = 0; - bool ricReqIdDecoded = false; DuDb *duDb = NULLP; RanFunction *ranFuncDb = NULLP; + RicSubscription *ricSubs = NULLP; RicRequestId ricReqId; RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP; @@ -2984,15 +3085,25 @@ uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricS { ricReqId.requestorId = ricSubsFailIe->value.choice.RICrequestID.ricRequestorID; ricReqId.instanceId = ricSubsFailIe->value.choice.RICrequestID.ricInstanceID; - ricReqIdDecoded = true; break; } case ProtocolIE_IDE2_id_RANfunctionID: { ranFuncId = ricSubsFailIe->value.choice.RANfunctionID; - if(duDb->ranFunction[ranFuncId-1].id == ranFuncId) + ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId); + if(!ranFuncDb) + { + DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId); + return RFAILED; + } + else { - ranFuncDb = &duDb->ranFunction[ranFuncId-1]; + /* Remove subscription entry from RAN Function */ + ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb); + if(ricSubs) + { + memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription)); + } } break; } @@ -3000,26 +3111,150 @@ uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricS default: /* No handling required as of now since this is a stub */ break; - } } } + } + } + return ROK; +} - /* Remove subscription entry from RAN Function */ - if(ranFuncDb && ricReqIdDecoded) - { - for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++) +/******************************************************************* + * + * @brief Processing of RIC Subscription Modification Required + * + * @details + * + * Function : ProcRicSubsModReqd + * + * Functionality: Processing of RIC Subscription Modification Required + * As of now, we do not identify any scenario where this message + * shall be sent by DU. Hence, bare minimum handling has been + * done here. + * + * @param DU ID + * RIC Subscription Modification Required IEs + * @return ROK-success + * RFAILED-failure + * + ******************************************************************/ +uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t *ricSubsModReqd) +{ + uint8_t ieIdx = 0, actionIdx = 0, duIdx = 0; + DuDb *duDb = NULLP; + uint16_t ranFuncId; + uint16_t actionId; + RicRequestId ricReqId; + RanFunction *ranFuncDb = NULLP; + RicSubscription *ricSubs = NULLP; + ActionInfo *action = NULLP; + RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP; + RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP; + RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP; + RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULLP; + RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULLP; + RicTmpActionList tmpActionList; + + memset(&ricReqId, 0, sizeof(RicRequestId)); + memset(&tmpActionList, 0, sizeof(RicTmpActionList)); + + SEARCH_DU_DB(duIdx, duId, duDb); + if(duDb == NULLP) + { + DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); + return RFAILED; + } + + for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++) + { + ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx]; + switch(ricSubsModReqdIe->id) + { + case ProtocolIE_IDE2_id_RICrequestID: { - if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) && - (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId)) + ricReqId.requestorId = ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID; + ricReqId.instanceId = ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID; + break; + } + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsModReqdIe->value.choice.RANfunctionID; + ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId); + if(!ranFuncDb) { - memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription)); - break; + /* If RIC Subscription not found, send RIC Subscription modification refuse to DU */ + DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RIC Subscription not found"); + //BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \ + CauseE2RICrequest_request_id_unknown); + return RFAILED; + } + + ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb); + if(!ricSubs) + { + /* If RAN Function not found, send RIC Subscription modification refuse to DU */ + DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RAN Function ID [%d] not found",ranFuncId); + //BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, \ + CauseE2_PR_ricRequest, CauseE2RICrequest_ran_function_id_invalid); + return RFAILED; } + break; } - } + case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List: + { + actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List; + for(actionIdx = 0; actionIdx < actionToBeModList->list.count; actionIdx++) + { + actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[actionIdx]; + actionId = actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID; + action = fetchActionInfoFromActionId(actionId, ricSubs); + if(action) + { + /* No modification required as of now, hence directly adding to the list */ + tmpActionList.actionModifiedList[tmpActionList.numActionModifed++] = actionId; + } + else + { + tmpActionList.actionModFailedList[tmpActionList.numActionModFailed++] = actionId; + } + } + break; + } + case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List: + { + actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List; + for(actionIdx = 0; actionIdx < actionToBeRmvList->list.count; actionIdx++) + { + actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[actionIdx]; + actionId = actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID; + action = fetchActionInfoFromActionId(actionId, ricSubs); + if(action) + { + tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId; + memset(action, 0, sizeof(ActionInfo)); + action->actionId = -1; + } + } + break; + } + default: + break; } } + + /* If none of the action modification/removal is supported, + * send RIC Subscription Modification Refuse + * Else + * send RIC Subscription Modification Confirm + */ + // TO BE DONE IN FUTURE GERRITS + /* + if(tmpActionList.numActionModifed || tmpActionList.numActionRemoved) + BuildAndSendRicSubsModConfirm(duId, ricReqId, ranFuncId, tmpActionList); + else + BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \ + CauseE2RICrequest_action_not_supported); + */ return ROK; } @@ -3319,6 +3554,14 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate); break; } + case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired: + { + DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Required"); + ProcRicSubsModReqd(*duId, \ + &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired); + break; + } + case InitiatingMessageE2__value_PR_ErrorIndicationE2: { DU_LOG("\nINFO --> E2AP : Error indication received"); diff --git a/src/ric_stub/ric_stub.h b/src/ric_stub/ric_stub.h index b4c159e83..b70613473 100644 --- a/src/ric_stub/ric_stub.h +++ b/src/ric_stub/ric_stub.h @@ -160,6 +160,16 @@ typedef struct RanFunction ranFunRejectedList[MAX_RAN_FUNCTION]; }RicTmpRanFunList; +typedef struct +{ + uint8_t numActionModifed; + uint8_t actionModifiedList[MAX_RIC_ACTION]; + uint8_t numActionModFailed; + uint8_t actionModFailedList[MAX_RIC_ACTION]; + uint8_t numActionRemoved; + uint8_t actionRemovedList[MAX_RIC_ACTION]; +}RicTmpActionList; + void readRicCfg(); void cuAppInmsgHdlr(Buffer *mBuf); void sctpNtfyInd(CmInetSctpNotification *ntfy);