X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fric_stub%2Fric_e2ap_msg_hdl.c;h=36335528aeae1770d8b236adab89c1f1026bfe5d;hb=61f1d2eec53a339d27c720eee5ded1869ec72fbb;hp=86129983c15d3e8cc5e4a307e28ddd462011b960;hpb=2f98230fb83e03fcdd354a7754415155ba353f7d;p=o-du%2Fl2.git diff --git a/src/ric_stub/ric_e2ap_msg_hdl.c b/src/ric_stub/ric_e2ap_msg_hdl.c index 86129983c..36335528a 100644 --- a/src/ric_stub/ric_e2ap_msg_hdl.c +++ b/src/ric_stub/ric_e2ap_msg_hdl.c @@ -175,6 +175,52 @@ uint8_t assignTransactionId(DuDb *duDb) return currTransId; } + /******************************************************************* + * + * @brief add RIC Subs action info + * + * @details + * + * Function : addRicSubsAction + * + * Functionality: add Ric Subs action info + * + * @parameter + * RIC action id + * List of action + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +CmLList *addRicSubsAction(uint8_t ricActionID, CmLListCp *actionSequence) +{ + ActionInfo *actionDb = NULLP; + CmLList *actionNode=NULLP; + + RIC_ALLOC(actionDb, sizeof(ActionInfo)); + if(actionDb==NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__); + return NULLP; + } + + actionDb->actionId = ricActionID; + RIC_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__); + RIC_FREE(actionDb, sizeof(ActionInfo)); + return NULLP; + } + + return actionNode; +} + /******************************************************************* * * @brief Sends E2 msg over SCTP @@ -479,22 +525,30 @@ RicSubscription *fetchSubsInfoFromRicReqId(RicRequestId ricReqId, RanFunction *r * * @params[in] Action ID * RIC Subscription DB + * List of action * @return Action Info DB * NULL, in case of failure * * ****************************************************************/ -ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo) +ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo, CmLList ** actionNode) { ActionInfo *actionInfoDb = NULLP; - if(ricSubscriptionInfo->actionSequence[actionId].actionId == actionId) + + CM_LLIST_FIRST_NODE(&ricSubscriptionInfo->actionSequence, *actionNode); + while(*actionNode) { - actionInfoDb = &ricSubscriptionInfo->actionSequence[actionId]; + actionInfoDb = (ActionInfo*)((*actionNode)->node); + if(actionInfoDb->actionId == actionId) + { + break; + } + *actionNode= (*actionNode)->next; } - else + if(actionInfoDb==NULLP) { 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); + subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\ + ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId); } return actionInfoDb; @@ -1784,7 +1838,7 @@ void FreeRicActionDefinition(E2SM_KPM_ActionDefinition_t actionDef) * RFAILED * * ****************************************************************/ -uint8_t fillRicActionDef(RICactionDefinition_t *ricActionDef) +uint8_t fillRicActionDef(RICactionDefinition_t *ricActionDef, uint8_t ricActionId, ConfigType configType) { uint8_t ret = RFAILED; asn_enc_rval_t encRetVal; @@ -1850,7 +1904,7 @@ uint8_t fillRicActionDef(RICactionDefinition_t *ricActionDef) break; /* Granularity Period */ - actionFormat1->granulPeriod = RIC_ACTION_GRANULARITY_PERIOD; /* In ms */ + actionFormat1->granulPeriod = RIC_ACTION_GRANULARITY_PERIOD(configType, ricActionId); /* In ms */ /* Prints the Msg formed */ xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, &actionDef); @@ -1903,7 +1957,7 @@ uint8_t fillRicActionDef(RICactionDefinition_t *ricActionDef) uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscription *ricSubsDb) { static uint8_t ricActionId = 0; - + CmLList *actionNode=NULLP; if(actionItem == NULLP) { DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); @@ -1918,8 +1972,7 @@ uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscr /* RIC Action ID */ actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId; - ricSubsDb->actionSequence[ricActionId].actionId = \ - actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID; + actionNode = addRicSubsAction(ricActionId, &ricSubsDb->actionSequence); ricActionId++; /* RIC Action Type */ @@ -1932,18 +1985,20 @@ uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscr DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); break; } - if(fillRicActionDef(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) != ROK) + if(fillRicActionDef(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, ricActionId, CONFIG_ADD) != ROK) { DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); break; } - ricSubsDb->numOfActions++; return ROK; } - - memset(&ricSubsDb->actionSequence[ricActionId], 0, sizeof(ActionInfo)); - ricSubsDb->actionSequence[ricActionId].actionId = -1; + + if(actionNode) + { + cmLListDelFrm(&ricSubsDb->actionSequence, actionNode); + deleteActionSequence(actionNode); + } return RFAILED; } @@ -2156,10 +2211,6 @@ uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); return RFAILED; } - for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++) - { - ricSubsInfo->actionSequence[actionIdx].actionId = -1; - } while(true) { @@ -2319,6 +2370,7 @@ void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricS RanFunction *ranFuncDb = NULLP; RicSubscription *ricSubs = NULLP; CmLList *ricSubsNode = NULLP; + CmLList *actionNode = NULLP; ActionInfo *action = NULLP; RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP; RICaction_NotAdmitted_List_t *notAdmitList = NULLP; @@ -2375,6 +2427,7 @@ void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricS notAdmitList = &ricSubsRspIe->value.choice.RICaction_NotAdmitted_List; for(notAdmitIdx = 0; notAdmitIdx < notAdmitList->list.count; notAdmitIdx++) { + actionNode=NULLP; actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\ value.choice.RICaction_NotAdmitted_Item.ricActionID; @@ -2382,12 +2435,11 @@ void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricS ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode); if(ricSubs) { - action = fetchActionInfoFromActionId(actionId, ricSubs); + action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode); if(action) { - memset(action, 0, sizeof(ActionInfo)); - ricSubs->actionSequence[actionId].actionId = -1; - ricSubs->numOfActions--; + cmLListDelFrm(&ricSubs->actionSequence, actionNode); + deleteActionSequence(actionNode); } } } @@ -4479,6 +4531,7 @@ uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t RanFunction *ranFuncDb = NULLP; RicSubscription *ricSubs = NULLP; CmLList *ricSubsNode = NULLP; + CmLList *actionNode = NULLP; ActionInfo *action = NULLP; RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP; RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP; @@ -4537,9 +4590,10 @@ uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List; for(actionIdx = 0; actionIdx < actionToBeModList->list.count; actionIdx++) { + actionNode=NULLP; actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[actionIdx]; actionId = actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID; - action = fetchActionInfoFromActionId(actionId, ricSubs); + action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode); if(action) { /* No modification required as of now, hence directly adding to the list */ @@ -4562,15 +4616,15 @@ uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List; for(actionIdx = 0; actionIdx < actionToBeRmvList->list.count; actionIdx++) { + actionNode=NULLP; actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[actionIdx]; actionId = actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID; - action = fetchActionInfoFromActionId(actionId, ricSubs); + action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode); if(action) { tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId; - memset(action, 0, sizeof(ActionInfo)); - action->actionId = -1; - ricSubs->numOfActions--; + cmLListDelFrm(&ricSubs->actionSequence, actionNode); + deleteActionSequence(actionNode); } } break; @@ -4963,6 +5017,63 @@ uint8_t BuildAndSendResetRequest(DuDb *duDb, CauseE2_PR causePresent, uint8_t re return ret; } +/****************************************************************** + * + * @brief Delete Ric subscription action + * + * @details + * + * Function : deleteActionSequence + * + * Functionality: Delete Ric subscription action + * + * @params[in] Action info + * + * @return void + * + * ****************************************************************/ +void deleteActionSequence(CmLList *actionNode) +{ + ActionInfo *action = NULLP; + + if(actionNode) + { + action = (ActionInfo*)actionNode->node; + memset(action, 0, sizeof(ActionInfo)); + RIC_FREE(actionNode->node, sizeof(ActionInfo)); + RIC_FREE(actionNode, sizeof(CmLList)); + } +} + +/****************************************************************** + * + * @brief Delete Ric subscription action list + * + * @details + * + * Function : deleteActionSequenceList + * + * Functionality: Delete Ric subscription action list + * + * @params[in] Action info list + * + * @return void + * + * ****************************************************************/ +void deleteActionSequenceList(CmLListCp *actionList) +{ + CmLList *actionNode=NULLP; + + CM_LLIST_FIRST_NODE(actionList, actionNode); + while(actionNode) + { + cmLListDelFrm(actionList, actionNode); + deleteActionSequence(actionNode); + CM_LLIST_FIRST_NODE(actionList, actionNode); + } + +} + /****************************************************************** * * @brief Delete Ric subscription node @@ -4984,14 +5095,9 @@ void deleteRicSubscriptionNode(CmLList *subscriptionNode) RicSubscription *ricSubscriptionInfo = NULLP; ricSubscriptionInfo = (RicSubscription*)subscriptionNode->node; - - for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++) - { - if(ricSubscriptionInfo->actionSequence[actionIdx].actionId > -1) - { - memset(&ricSubscriptionInfo->actionSequence[actionIdx], 0, sizeof(ActionInfo)); - } - } + + deleteActionSequenceList(&ricSubscriptionInfo->actionSequence); + memset(ricSubscriptionInfo, 0, sizeof(RicSubscription)); RIC_FREE(subscriptionNode->node, sizeof(RicSubscription)); RIC_FREE(subscriptionNode, sizeof(CmLList)); @@ -7134,149 +7240,1278 @@ void ProcRicSubsDeleteFailure(RICsubscriptionDeleteFailure_t *ricSubsDeleteFail) } } -/******************************************************************* -* -* @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(uint32_t *duId, Buffer *mBuf) + +/****************************************************************** + * + * @brief Processes the Ric Subs delete rsp msg + * + * @details + * + * Function : ProcRicSubsDeleteRsp + * + * Functionality: Processes the Ric Subs delete rsp msg + * + * @params[in] + * Ric Subs delete rsp information + * + * @return void + * + * ****************************************************************/ +void ProcRicSubsDeleteRsp(uint32_t duId, RICsubscriptionDeleteResponse_t *ricSubsDeleteRsp) { - int i; - char *recvBuf; - MsgLen copyCnt; - MsgLen recvBufLen; - E2AP_PDU_t *e2apMsg; - asn_dec_rval_t rval; /* Decoder return value */ - E2AP_PDU_t e2apasnmsg ; - - DU_LOG("\nINFO --> 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); - RIC_ALLOC(recvBuf, (Size)recvBufLen); + uint8_t ieIdx = 0; + uint8_t duIdx= 0; + uint16_t ranFuncId=0; + RanFunction *ranFuncDb = NULLP; + RicRequestId ricReqId; + DuDb *duDb = NULLP; + RicSubscription *ricSubs = NULLP; + CmLList *ricSubsNode = NULLP; - 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) + SEARCH_DU_DB(duIdx, duId, duDb); + if(duDb == NULLP) { - DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt); + DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); return; } - DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : "); - for(i=0; i< recvBufLen; i++) + if(!ricSubsDeleteRsp) { - DU_LOG("%x",recvBuf[i]); + DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp pointer is null"); + return; } - /* 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); - RIC_FREE(recvBuf, (Size)recvBufLen); - - if(rval.code == RC_FAIL || rval.code == RC_WMORE) + if(!ricSubsDeleteRsp->protocolIEs.list.array) { - DU_LOG("\nERROR --> E2AP : ASN decode failed"); + DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp array pointer is null"); return; } - DU_LOG("\n"); - xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); - - switch(e2apMsg->present) + for(ieIdx=0; ieIdx < ricSubsDeleteRsp->protocolIEs.list.count; ieIdx++) { - case E2AP_PDU_PR_initiatingMessage: + if(ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]) + { + switch(ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->id) { - switch(e2apMsg->choice.initiatingMessage->value.present) - { - case InitiatingMessageE2__value_PR_E2setupRequest: - { - DU_LOG("\nINFO --> E2AP : E2 setup request received"); - ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest); - break; - } - case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate: - { - DU_LOG("\nINFO --> E2AP : E2 node config update received"); - ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate); - break; - } - case InitiatingMessageE2__value_PR_ResetRequestE2: - { - DU_LOG("\nINFO --> E2AP : E2 Reset Request received"); - ProcResetRequest(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2); - break; - } - case InitiatingMessageE2__value_PR_RICindication: - { - DU_LOG("\nINFO --> E2AP : RIC Indication received"); - break; - } - case InitiatingMessageE2__value_PR_RICserviceUpdate: - { - DU_LOG("\nINFO --> E2AP : RIC Service update received"); - 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_RICsubscriptionDeleteRequired: + case ProtocolIE_IDE2_id_RICrequestID: + { + ricReqId.requestorId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricRequestorID; + ricReqId.instanceId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricInstanceID; + break; + } + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID; + ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId); + if(!ranFuncDb) { - DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Required"); - ProcRicSubsDeleteReqd(*duId, \ - &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired); - break; + DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId); + return; } - case InitiatingMessageE2__value_PR_ErrorIndicationE2: - { - DU_LOG("\nINFO --> E2AP : Error indication received"); - break; - } - case InitiatingMessageE2__value_PR_E2RemovalRequest: + ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode); + if(ricSubs) { - DU_LOG("\nINFO --> E2AP : E2 Removal request received"); - procE2RemovalRequest(*duId,\ - &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest); - break; + deleteRicSubscriptionNode(ricSubsNode); + DU_LOG("\nINFO --> E2AP : Ric subscription node deleted successfully"); } - default: + else { - DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \ - e2apMsg->choice.initiatingMessage->value.present); + DU_LOG("\nERROR --> E2AP : Ric subscription node is not present "); return; } - }/* End of switch(initiatingMessage) */ - break; + break; + } } - case E2AP_PDU_PR_successfulOutcome: + } + } +} + + + /****************************************************************** + * + * @brief Processes the Ric Subs modification failure msg + * + * @details + * + * Function : procRicSubsModificationFailure + * + * Functionality: Processes the Ric Subs modification failure msg + * + * @params[in] + * Ric Subs modification failure information + * + * @return void + * + * ****************************************************************/ + void ProcRicSubsModificationFailure(RICsubscriptionModificationFailure_t *ricSubsModificationFail) + { + uint8_t ieIdx = 0; + uint16_t ranFuncId=0; + CauseE2_t *cause = NULLP; + RICrequestID_t ricRequestID; + + DU_LOG("\nINFO --> E2AP : Ric subscription modification failure received"); + + if(!ricSubsModificationFail) + { + DU_LOG("\nERROR --> E2AP : ricSubsModificationFail pointer is null"); + return; + } + + if(!ricSubsModificationFail->protocolIEs.list.array) + { + DU_LOG("\nERROR --> E2AP : ricSubsModificationFail array pointer is null"); + return; + } + + for(ieIdx=0; ieIdx < ricSubsModificationFail->protocolIEs.list.count; ieIdx++) + { + if(ricSubsModificationFail->protocolIEs.list.array[ieIdx]) + { + switch(ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_RICrequestID: + { + memcpy(&ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t)); + DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID); + break; + } + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID; + DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId); + break; + } + case ProtocolIE_IDE2_id_CauseE2: + { + cause = &ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.CauseE2; + printE2ErrorCause(cause); + break; + } + default: + { + DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id); + break; + } + } + } + } + } + +/******************************************************************* + * + * @brief Free RIC Subscription action to be added list + * + * @details + * + * Function : FreeRicSubsActionToBeAdded + * + * Functionality: Free the RIC Subscription action to be added list + * + * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails + * @return void + * + * ****************************************************************/ +void FreeRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails) +{ + uint8_t elementIdx = 0; + RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP; + + if(subsDetails->list.array) + { + for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++) + { + if(subsDetails->list.array[elementIdx]) { - switch(e2apMsg->choice.successfulOutcome->value.present) - { - case SuccessfulOutcomeE2__value_PR_ResetResponseE2: - { + addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx]; + RIC_FREE(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf, \ + addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.size); + RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t)); + } + } + RIC_FREE(subsDetails->list.array, subsDetails->list.size); + } +} + +/******************************************************************* + * + * @brief Free RIC Subscription action to be removed list + * + * @details + * + * Function : FreeRicSubsActionToBeRemoved + * + * Functionality: Free the RIC Subscription action to be removed list + * + * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails + * @return void + * + * ****************************************************************/ +void FreeRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails) +{ + uint8_t elementIdx = 0; + + if(subsDetails->list.array) + { + for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++) + { + RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t)); + } + RIC_FREE(subsDetails->list.array, subsDetails->list.size); + } +} + +/******************************************************************* + * + * @brief Free RIC Subscription action to be modify + * + * @details + * + * Function : FreeRicSubsActionToBeModified + * + * Functionality: Free the RIC Subscription action to be modify + * + * @params[in] RICactions_ToBeModifiedForModification_List_t List + * @return void + * + * ****************************************************************/ +void FreeRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails) +{ + uint8_t elementIdx = 0; + RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP; + + if(subsDetails->list.array) + { + 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) + { + RIC_FREE(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf, \ + actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->size); + RIC_FREE(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t)); + } + RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t)) + } + } + RIC_FREE(subsDetails->list.array, subsDetails->list.size); + } +} + +/******************************************************************* + * + * @brief Free RIC Subscription modification Request + * + * @details + * + * Function :FreeRicSubscriptionModReq + * + * Functionality : Free RIC Subscription modification Request + * + * @params[in] E2AP_PDU + * @return void + * + ******************************************************************/ +void FreeRicSubscriptionModReq(E2AP_PDU_t *e2apRicMsg) +{ + uint8_t idx = 0; + RICsubscriptionModificationRequest_t *ricSubscriptionModReq =NULLP; + RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe=NULLP; + + if(e2apRicMsg) + { + if(e2apRicMsg->choice.initiatingMessage) + { + ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest; + if(ricSubscriptionModReq->protocolIEs.list.array) + { + for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++) + { + if(ricSubscriptionModReq->protocolIEs.list.array[idx]) + { + ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx]; + switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id) + { + case ProtocolIE_IDE2_id_RICrequestID: + break; + case ProtocolIE_IDE2_id_RANfunctionID: + break; + case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List: + { + FreeRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List)); + break; + } + case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List: + { + FreeRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List)); + break; + } + case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List: + { + FreeRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List)); + break; + } + default: + { + DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id); + break; + } + + } + + RIC_FREE(ricSubscriptionModReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionModificationRequest_IEs_t)); + } + } + RIC_FREE(ricSubscriptionModReq->protocolIEs.list.array, ricSubscriptionModReq->protocolIEs.list.size); + } + RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + } + RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* +* +* @brief Build Ric subscription action to be modify list +* +* @details +* +* Function : BuildRicSubsActionToBeModify +* +* Functionality: Build Ric subscription action to be modify list +* +* @params[in] +* RICactions_ToBeModifiedForModification_List_t to be filled +* Num of action to be modify +* List of action to be modify +* +* @return ROK - success +* RFAILED - failure +* +******************************************************************/ + +uint8_t BuildRicSubsActionToBeModify(RICactions_ToBeModifiedForModification_List_t *modifyActionList, uint8_t numOfActionToBeModify, ActionInfo *actionToBeModify) +{ + uint8_t arrIdx=0; + RICaction_ToBeModifiedForModification_ItemIEs_t *modifiedActionItemIe=NULLP; + + modifyActionList->list.count = numOfActionToBeModify; + modifyActionList->list.size = modifyActionList->list.count * sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t*); + RIC_ALLOC(modifyActionList->list.array, modifyActionList->list.size); + if(!modifyActionList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx< modifyActionList->list.count; arrIdx++) + { + RIC_ALLOC(modifyActionList->list.array[arrIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t)); + if(!modifyActionList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + modifiedActionItemIe = (RICaction_ToBeModifiedForModification_ItemIEs_t*)modifyActionList->list.array[arrIdx]; + modifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item; + modifiedActionItemIe->criticality = CriticalityE2_ignore; + modifiedActionItemIe->value.present = RICaction_ToBeModifiedForModification_ItemIEs__value_PR_RICaction_ToBeModifiedForModification_Item; + modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID = actionToBeModify[arrIdx].actionId; + + /* RIC Action Definition */ + RIC_ALLOC(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t)); + if(!modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + if(fillRicActionDef(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition,\ + actionToBeModify[arrIdx].actionId, CONFIG_MOD) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + } + return ROK; +} + +/******************************************************************* +* +* @brief Build Ric subscription action to be removed list +* +* @details +* +* Function : BuildRicSubsActionToBeRemoved +* +* Functionality: Build Ric subscription action to be removed list +* +* @params[in] +* RICactions_ToBeRemovedForModification_List_t to be filled +* Num Of Action To Be Remove +* Action remove list +* +* @return ROK - success +* RFAILED - failure +* +******************************************************************/ + +uint8_t BuildRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *removeActionList, uint8_t numOfActionToBeRemove, ActionInfo *actionToBeRemove) +{ + uint8_t arrIdx=0; + RICaction_ToBeRemovedForModification_ItemIEs_t *removeActionItemIe=NULLP; + + removeActionList->list.count = numOfActionToBeRemove; + removeActionList->list.size = removeActionList->list.count * sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t*); + RIC_ALLOC(removeActionList->list.array, removeActionList->list.size); + if(!removeActionList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx< removeActionList->list.count; arrIdx++) + { + RIC_ALLOC(removeActionList->list.array[arrIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t)); + if(!removeActionList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + removeActionItemIe = (RICaction_ToBeRemovedForModification_ItemIEs_t*)removeActionList->list.array[arrIdx]; + removeActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item; + removeActionItemIe->criticality = CriticalityE2_ignore; + removeActionItemIe->value.present = RICaction_ToBeRemovedForModification_ItemIEs__value_PR_RICaction_ToBeRemovedForModification_Item; + removeActionItemIe->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID = actionToBeRemove[arrIdx].actionId; + } + return ROK; +} + +/******************************************************************* +* +* @brief Build Ric subscription action to be added list +* +* @details +* +* Function : BuildRicSubsActionToBeAdded +* +* Functionality: Build Ric subscription action to be added list +* +* @params[in] +* RICactions_ToBeAddedForModification_List_t to be filled +* Num Of Action To Be added +* Action add list +* +* @return ROK - success +* RFAILED - failure +* +******************************************************************/ + +uint8_t BuildRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *addedActionList, RicSubscription **ricSubsInfo, uint8_t numOfActionToBeAdded, ActionInfo *actionToBeAdded) +{ + uint8_t arrIdx=0; + CmLList *actionNode=NULLP; + RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe; + + addedActionList->list.count = numOfActionToBeAdded; + addedActionList->list.size = addedActionList->list.count * sizeof(RICaction_ToBeAddedForModification_ItemIEs_t*); + RIC_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++) + { + RIC_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t)); + if(!addedActionList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx]; + addedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item; + addedActionItemIe->criticality = CriticalityE2_ignore; + addedActionItemIe->value.present = RICaction_ToBeAddedForModification_ItemIEs__value_PR_RICaction_ToBeAddedForModification_Item; + addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionID = actionToBeAdded[arrIdx].actionId; + + addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionType = RICactionType_report; + + if(fillRicActionDef(&addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition, \ + actionToBeAdded[arrIdx].actionId, CONFIG_ADD) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + actionNode = addRicSubsAction((*ricSubsInfo)->actionSequence.count, &(*ricSubsInfo)->actionSequence); + if(actionNode == NULLP) + { + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + } + return ROK; +} + +/******************************************************************* + * + * @brief Builds and Send the RicSubscriptionModReq + * + * @details + * + * Function : BuildAndSendRicSubscriptionModReq + * + * Functionality:Builds and Send the RicSubscriptionModReq + * + * @params[in] + * Du databse + * Ric subs information + * List of ric subs action which needs to modify/add/remove + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t BuildAndSendRicSubscriptionModReq(DuDb *duDb, RicSubscription **ricSubsInfo, RicSubsModReq ricSubsModReq) +{ + uint8_t ret = RFAILED; + uint8_t elementCnt = 0; + uint8_t idx = 0, cfgIdx=0; + asn_enc_rval_t encRetVal; /* Encoder return value */ + E2AP_PDU_t *e2apRicMsg = NULL; + RICsubscriptionModificationRequest_t *ricSubscriptionModReq; + RanFunction *ranFuncDb = &duDb->ranFunction[0]; + CmLList *subscriptionNode = NULLP; + + DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n"); + + while(true) + { + RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t)); + if(e2apRicMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage; + RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + if(e2apRicMsg->choice.initiatingMessage == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification; + e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; + e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest; + + ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest; + + /* Increasing the elment count based on the number of configured action to be add, mod, delete */ + elementCnt = 2; + if(ricSubsModReq.numOfActionToBeAdded) + elementCnt++; + if(ricSubsModReq.numOfActionToBeModify) + elementCnt++; + if(ricSubsModReq.numOfActionToBeRemove) + elementCnt++; + + ricSubscriptionModReq->protocolIEs.list.count = elementCnt; + ricSubscriptionModReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequest_IEs_t); + + /* Initialize the subscription members */ + RIC_ALLOC(ricSubscriptionModReq->protocolIEs.list.array, ricSubscriptionModReq->protocolIEs.list.size); + if(ricSubscriptionModReq->protocolIEs.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + for(idx=0; idxprotocolIEs.list.array[idx], sizeof(RICsubscriptionModificationRequest_IEs_t)); + if(ricSubscriptionModReq->protocolIEs.list.array[idx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + if(idx < elementCnt) + break; + + /* Filling RIC Request Id */ + idx = 0; + ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID; + ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present =\ + RICsubscriptionModificationRequest_IEs__value_PR_RICrequestID; + ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = (*ricSubsInfo)->requestId.requestorId; + ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = (*ricSubsInfo)->requestId.instanceId; + + /* Filling RAN Function Id */ + idx++; + ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID; + ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present =\ + RICsubscriptionModificationRequest_IEs__value_PR_RANfunctionID; + ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = (*ricSubsInfo)->ranFuncId; + + if(ricSubsModReq.numOfActionToBeRemove) + { + /* Filling RIC Subscription action to be removed */ + idx++; + ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List; + ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore; + ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeRemovedForModification_List; + if(BuildRicSubsActionToBeRemoved(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeRemovedForModification_List,\ + ricSubsModReq.numOfActionToBeRemove, ricSubsModReq.actionToBeRemove) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + if(ricSubsModReq.numOfActionToBeModify) + { + /* Filling RIC Subscription action to be modified */ + idx++; + ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List; + ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore; + ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeModifiedForModification_List; + if(BuildRicSubsActionToBeModify(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeModifiedForModification_List,\ + ricSubsModReq.numOfActionToBeModify, ricSubsModReq.actionToBeModify) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + + if(ricSubsModReq.numOfActionToBeAdded) + { + /* Filling RIC Subscription action to be added */ + idx++; + ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List; + ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore; + ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeAddedForModification_List; + if(BuildRicSubsActionToBeAdded(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeAddedForModification_List,\ + ricSubsInfo, ricSubsModReq.numOfActionToBeAdded, ricSubsModReq.actionToBeAdded) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + } + + /* Prints the Msg formed */ + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg); + + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf); + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionModRequest structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionModRequest\n"); + for(int i=0; i< encBufSize; i++) + { + DU_LOG("%x",encBuf[i]); + } + } + + /* Sending msg */ + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK) + { + DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed"); + break; + } + + ret = ROK; + break; + } + + FreeRicSubscriptionModReq(e2apRicMsg); + return ret; +} + +/******************************************************************* + * + * @brief Builds RicSubscriptionModReq + * + * @details + * + * Function : BuildRicSubscriptionModReq + * + * Functionality:Builds the RicSubscriptionModReq + * + * @params[in] + * Du databse + * @return void + * + * ****************************************************************/ + +void BuildRicSubsModificationReq(DuDb *duDb, RicSubscription *ricSubsInfo) +{ + CmLList *actionNode=NULLP; + uint8_t actionToBeAdded =0; + uint8_t actionIdx =0, tmpActionIdx=0; + ActionInfo *actionInfoDb = NULLP; + RicSubsModReq ricSubsModReq; + + if(ricSubsInfo) + { + memset(&ricSubsModReq, 0, sizeof(RicSubsModReq)); + + + CM_LLIST_FIRST_NODE(&ricSubsInfo->actionSequence, actionNode); + while(actionNode) + { + actionInfoDb = (ActionInfo*)(actionNode->node); + /* Change the condition based on the action required to be modiified or removed */ + if(((actionInfoDb->actionId+1)%2) == 0) + { + tmpActionIdx = ricSubsModReq.numOfActionToBeModify; + ricSubsModReq.actionToBeModify[tmpActionIdx].actionId = actionInfoDb->actionId; + ricSubsModReq.numOfActionToBeModify++; + } + else + { + tmpActionIdx = ricSubsModReq.numOfActionToBeRemove; + ricSubsModReq.actionToBeRemove[tmpActionIdx].actionId = actionInfoDb->actionId; + ricSubsModReq.numOfActionToBeRemove++; + } + actionNode= actionNode->next; + } + /* Change the value of actionToBeAdded based on the number of action required to be added */ + actionToBeAdded =1; + tmpActionIdx = ricSubsInfo->actionSequence.count; + for(actionIdx=0; actionIdx E2AP : failed to build and send RIC Subscription Modification"); + return ; + } + } +} + +/**************************************************************** + * + * @brief Processing RIC Subscription action modified list + * + * @details + * + * Function :ProcessingRicSubsActionModified + * + * Functionality: Processing the RIC Subscription action modified list + * + * @params[in] RICactions_AddedForModification_List_t + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionModified(RICactions_ModifiedForModification_List_t *actionModifiedList) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + ActionInfo *action=NULLP; + CmLList *actionNode =NULLP; + RICaction_ModifiedForModification_ItemIEs_t *modifiedActionItemIe =NULLP; + + if(actionModifiedList->list.array) + { + for(elementIdx = 0; elementIdx < actionModifiedList->list.count; elementIdx++) + { + if(actionModifiedList->list.array[elementIdx]) + { + modifiedActionItemIe=(RICaction_ModifiedForModification_ItemIEs_t*)actionModifiedList->list.array[elementIdx]; + actionId = modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID; + DU_LOG("\nInfo --> E2AP : Action id %d modified successfully", actionId); + } + + } + + } +} + +/**************************************************************** + * + * @brief Processing RIC Subscription action added list + * + * @details + * + * Function : ProcessingRicSubsActionAdded + * + * Functionality: Processing RIC Subscription action added list + * + * @params[in] RICactions_AddedForModification_List_t + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionAdded(RICactions_AddedForModification_List_t *actionAddedList) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + ActionInfo *action=NULLP; + CmLList *actionNode =NULLP; + RICaction_AddedForModification_ItemIEs_t *addedActionItemIe =NULLP; + + if(actionAddedList->list.array) + { + for(elementIdx = 0; elementIdx < actionAddedList->list.count; elementIdx++) + { + if(actionAddedList->list.array[elementIdx]) + { + addedActionItemIe=(RICaction_AddedForModification_ItemIEs_t*)actionAddedList->list.array[elementIdx]; + actionId = addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID; + DU_LOG("\nInfo --> E2AP : Action id %d added successfully", actionId); + } + + } + + } +} + +/**************************************************************** + * + * @brief Processing RIC Subscription action deleted list + * + * @details + * + * Function : ProcessingRicSubsActionRemoved + * + * Functionality: Processing RIC Subscription action deleted list + * + * @params[in] RICactions_RemovedForModification_List_t + * Ric Subscription info + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionRemoved(RICactions_RemovedForModification_List_t *actionRemovedList, RicSubscription *ricSubs) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + ActionInfo *action=NULLP; + CmLList *actionNode =NULLP; + RICaction_RemovedForModification_ItemIEs_t *removedActionItemIe =NULLP; + + if(actionRemovedList->list.array) + { + for(elementIdx = 0; elementIdx < actionRemovedList->list.count; elementIdx++) + { + if(actionRemovedList->list.array[elementIdx]) + { + removedActionItemIe=(RICaction_RemovedForModification_ItemIEs_t*)actionRemovedList->list.array[elementIdx]; + actionId = removedActionItemIe->value.choice.RICaction_RemovedForModification_Item.ricActionID; + action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode); + if(action) + { + cmLListDelFrm(&ricSubs->actionSequence, actionNode); + deleteActionSequence(actionNode); + DU_LOG("\nInfo --> E2AP : Action id %d removed successfully", actionId); + } + } + + } + + } +} + +/******************************************************************* + * + * @brief Processing RIC Subscription action failed to be + * removed list + * + * @details + * + * Function : ProcessingRicSubsActionFailedToBeRemoved + * + * Functionality: Processing the RIC Subscription action failed + * to be removed list + * + * @params[in] RICactions_FailedToBeRemovedForModification_List_t + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionFailedToBeRemoved(RICactions_FailedToBeRemovedForModification_List_t *actionFailedToBeRemoved) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + RICaction_FailedToBeRemovedForModification_ItemIEs_t *failedToBeRemovedActionItemIe =NULLP; + + if(actionFailedToBeRemoved->list.array) + { + for(elementIdx = 0; elementIdx < actionFailedToBeRemoved->list.count; elementIdx++) + { + if(actionFailedToBeRemoved->list.array[elementIdx]) + { + failedToBeRemovedActionItemIe=(RICaction_FailedToBeRemovedForModification_ItemIEs_t*)actionFailedToBeRemoved->list.array[elementIdx]; + actionId = failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID; + DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId, __func__); + printE2ErrorCause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause); + } + + } + + } +} + +/**************************************************************** + * + * @brief Processing RIC Subscription action failed to be + * add list + * + * @details + * + * Function : ProcessingRicSubsActionFailedToBeAdded + * + * Functionality: Processing the RIC Subscription action failed + * to be add list + * + * @params[in] RICactions_FailedToBeAddedForModification_List_t + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionFailedToBeAdded(RICactions_FailedToBeAddedForModification_List_t *actionfailedToBeAddedList, RicSubscription *ricSubs) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + ActionInfo *action=NULLP; + CmLList *actionNode =NULLP; + RICaction_FailedToBeAddedForModification_ItemIEs_t *failedToBeAddedActionItemIe =NULLP; + + if(actionfailedToBeAddedList->list.array) + { + for(elementIdx = 0; elementIdx < actionfailedToBeAddedList->list.count; elementIdx++) + { + if(actionfailedToBeAddedList->list.array[elementIdx]) + { + failedToBeAddedActionItemIe=(RICaction_FailedToBeAddedForModification_ItemIEs_t*)actionfailedToBeAddedList->list.array[elementIdx]; + actionId = failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.ricActionID; + action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode); + if(action) + { + cmLListDelFrm(&ricSubs->actionSequence, actionNode); + deleteActionSequence(actionNode); + } + DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__); + printE2ErrorCause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause); + } + + } + + } +} + +/******************************************************************* + * + * @brief Processing RIC Subscription action failed to be + * modified list + * + * @details + * + * Function :ProcessingRicSubsActionFailedToBeModified + * + * Functionality: Processing the RIC Subscription action failed + * to be modified list + * + * @params[in] RICactions_FailedToBeModifiedForModification_List_t + * @return void + * + * ****************************************************************/ +void ProcessingRicSubsActionFailedToBeModified(RICactions_FailedToBeModifiedForModification_List_t *actionFailedToBeModifiedList) +{ + uint8_t actionId=0; + uint8_t elementIdx = 0; + RICaction_FailedToBeModifiedForModification_ItemIEs_t *failedToBeModifiedActionItemIe =NULLP; + + if(actionFailedToBeModifiedList->list.array) + { + for(elementIdx = 0; elementIdx < actionFailedToBeModifiedList->list.count; elementIdx++) + { + if(actionFailedToBeModifiedList->list.array[elementIdx]) + { + failedToBeModifiedActionItemIe=(RICaction_FailedToBeModifiedForModification_ItemIEs_t*)actionFailedToBeModifiedList->list.array[elementIdx]; + actionId = failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID; + DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__); + printE2ErrorCause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause); + } + + } + + } +} + +/****************************************************************** + * + * @brief Processes the Ric Subs modification rsp msg + * + * @details + * + * Function : ProcRicSubsModificationRsp + * + * Functionality: Processes the Ric Subs modification rsp msg + * + * @params[in] + * Ric Subs modification rsp information + * + * @return void + * + * ****************************************************************/ +void ProcRicSubsModificationRsp(uint32_t duId, RICsubscriptionModificationResponse_t *ricSubsModificationRsp) +{ + uint8_t ieIdx = 0; + uint8_t duIdx= 0; + uint16_t ranFuncId=0; + RanFunction *ranFuncDb = NULLP; + RicRequestId ricReqId; + DuDb *duDb = NULLP; + RicSubscription *ricSubs = NULLP; + CmLList *ricSubsNode = NULLP; + + SEARCH_DU_DB(duIdx, duId, duDb); + if(duDb == NULLP) + { + DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); + return; + } + + if(!ricSubsModificationRsp) + { + DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp pointer is null"); + return; + } + + if(!ricSubsModificationRsp->protocolIEs.list.array) + { + DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp array pointer is null"); + return; + } + + for(ieIdx=0; ieIdx < ricSubsModificationRsp->protocolIEs.list.count; ieIdx++) + { + if(ricSubsModificationRsp->protocolIEs.list.array[ieIdx]) + { + switch(ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_RICrequestID: + { + ricReqId.requestorId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricRequestorID; + ricReqId.instanceId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricInstanceID; + break; + } + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID; + ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId); + if(!ranFuncDb) + { + DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId); + return; + } + + ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode); + if(!ricSubs) + { + DU_LOG("\nERROR --> E2AP : Ric subscription node is not present "); + return; + } + break; + } + case ProtocolIE_IDE2_id_RICactionsRemovedForModification_List: + { + ProcessingRicSubsActionRemoved(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_RemovedForModification_List, ricSubs); + break; + } + case ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List: + { + ProcessingRicSubsActionFailedToBeRemoved(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeRemovedForModification_List); + break; + } + case ProtocolIE_IDE2_id_RICactionsModifiedForModification_List: + { + ProcessingRicSubsActionModified(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_ModifiedForModification_List); + break; + } + case ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List: + { + ProcessingRicSubsActionFailedToBeModified(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeModifiedForModification_List); + break; + } + case ProtocolIE_IDE2_id_RICactionsAddedForModification_List: + { + ProcessingRicSubsActionAdded(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_AddedForModification_List); + break; + } + case ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List: + { + ProcessingRicSubsActionFailedToBeAdded(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeAddedForModification_List, ricSubs); + break; + } + default: + { + DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id); + break; + } + } + } + } +} + +/******************************************************************* +* +* @brief Handles received E2AP message and sends back response +* +* @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(uint32_t *duId, Buffer *mBuf) +{ + int i; + char *recvBuf; + MsgLen copyCnt; + MsgLen recvBufLen; + E2AP_PDU_t *e2apMsg; + asn_dec_rval_t rval; /* Decoder return value */ + E2AP_PDU_t e2apasnmsg ; + + DU_LOG("\nINFO --> 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); + RIC_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; + } + + DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : "); + for(i=0; i< recvBufLen; i++) + { + DU_LOG("%x",recvBuf[i]); + } + + /* 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); + RIC_FREE(recvBuf, (Size)recvBufLen); + + if(rval.code == RC_FAIL || rval.code == RC_WMORE) + { + DU_LOG("\nERROR --> E2AP : ASN decode failed"); + return; + } + DU_LOG("\n"); + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); + + switch(e2apMsg->present) + { + case E2AP_PDU_PR_initiatingMessage: + { + switch(e2apMsg->choice.initiatingMessage->value.present) + { + case InitiatingMessageE2__value_PR_E2setupRequest: + { + DU_LOG("\nINFO --> E2AP : E2 setup request received"); + ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest); + break; + } + case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate: + { + DU_LOG("\nINFO --> E2AP : E2 node config update received"); + ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate); + break; + } + case InitiatingMessageE2__value_PR_ResetRequestE2: + { + DU_LOG("\nINFO --> E2AP : E2 Reset Request received"); + ProcResetRequest(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2); + break; + } + case InitiatingMessageE2__value_PR_RICindication: + { + DU_LOG("\nINFO --> E2AP : RIC Indication received"); + break; + } + case InitiatingMessageE2__value_PR_RICserviceUpdate: + { + DU_LOG("\nINFO --> E2AP : RIC Service update received"); + 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_RICsubscriptionDeleteRequired: + { + DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Required"); + ProcRicSubsDeleteReqd(*duId, \ + &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired); + break; + } + + case InitiatingMessageE2__value_PR_ErrorIndicationE2: + { + DU_LOG("\nINFO --> E2AP : Error indication received"); + break; + } + case InitiatingMessageE2__value_PR_E2RemovalRequest: + { + DU_LOG("\nINFO --> E2AP : E2 Removal request received"); + procE2RemovalRequest(*duId,\ + &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest); + break; + } + default: + { + DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \ + e2apMsg->choice.initiatingMessage->value.present); + return; + } + }/* End of switch(initiatingMessage) */ + break; + } + case E2AP_PDU_PR_successfulOutcome: + { + switch(e2apMsg->choice.successfulOutcome->value.present) + { + case SuccessfulOutcomeE2__value_PR_ResetResponseE2: + { DU_LOG("\nINFO --> E2AP : Reset response received"); ProcResetResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2); break; @@ -7297,6 +8532,16 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) ProcE2ConnectionUpdateAck(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge); break; } + case SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse: + { + ProcRicSubsDeleteRsp(*duId, &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse); + break; + } + case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationResponse: + { + ProcRicSubsModificationRsp(*duId, &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse); + break; + } default: { DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \ @@ -7332,6 +8577,11 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) ProcRicSubsDeleteFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure); break; } + case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure: + { + ProcRicSubsModificationFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure); + break; + } default: { DU_LOG("\nERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \