X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fric_stub%2Fric_e2ap_msg_hdl.c;h=ee63fbf7e40c398d53adc50559ce8f72bad5e5db;hb=349ce6153f82d03f3ec90e2450788ea15abe05ed;hp=8cc3806d06112e37bda866aa613df2d434ad2018;hpb=47fcf084ca2e186a81772c24a3a213acb5ee71d0;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 8cc3806d0..ee63fbf7e 100644 --- a/src/ric_stub/ric_e2ap_msg_hdl.c +++ b/src/ric_stub/ric_e2ap_msg_hdl.c @@ -100,7 +100,7 @@ uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId) if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK) { ODU_PRINT_MSG(mBuf, 0,0); - + if(sctpSend(duId, mBuf) != ROK) { DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed"); @@ -121,10 +121,329 @@ uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId) DU_LOG("\nERROR --> E2AP : Failed to allocate memory"); return RFAILED; } - + 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 + * + * @details + * + * Function : FreeE2ConfigUpdateFail + * + * Functionality: deallocate memory allocated in E2 Node Config Update Failure + * + * @params[in] E2AP_PDU_t *e2apMsg + * + * @return void + * ****************************************************************/ + +void FreeE2ConfigUpdateFail(E2AP_PDU_t *e2apMsg) +{ + uint8_t arrIdx = 0; + E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL; + + if(e2apMsg) + { + if(e2apMsg->choice.unsuccessfulOutcome) + { + e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure; + if(e2NodeCfgUpdFail->protocolIEs.list.array) + { + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + { + RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateFailure_IEs_t)); + } + RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array, e2NodeCfgUpdFail->protocolIEs.list.size); + } + RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t)); + } + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* + * + * @brief Buld and send the E2 Node Config Update failure + * + * @details + * + * Function : BuildAndSendE2NodeConfigUpdateFailure + * + * Functionality: + * - Buld and send the E2 Node Config Update failure + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t BuildAndSendE2NodeConfigUpdateFailure(uint32_t duId, uint8_t transId, uint8_t causeInfo, uint8_t causeReason) +{ + E2AP_PDU_t *e2apMsg = NULL; + asn_enc_rval_t encRetVal; + uint8_t arrIdx=0; + uint8_t elementCnt=0; + bool memAllocFailed = false; + E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdateFail=NULL; + + DU_LOG("\nINFO --> E2AP : Building E2 Node Config Update failure\n"); + while(true) + { + RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); + if(e2apMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + break; + } + e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome; + RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2)); + if(e2apMsg->choice.unsuccessfulOutcome == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + break; + } + + e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate; + e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject; + e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure; + e2NodeCfgUpdateFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure; + + elementCnt = 3; + e2NodeCfgUpdateFail->protocolIEs.list.count = elementCnt; + e2NodeCfgUpdateFail->protocolIEs.list.size = elementCnt * sizeof(struct E2nodeConfigurationUpdateFailure_IEs *); + + RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array, e2NodeCfgUpdateFail->protocolIEs.list.size); + if(e2NodeCfgUpdateFail->protocolIEs.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure array failed"); + break; + } + + for(arrIdx=0; arrIdxprotocolIEs.list.array[arrIdx], sizeof(struct E2nodeConfigurationUpdateFailure_IEs)); + if(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure IEs failed"); + memAllocFailed = true; + break; + } + } + + if(memAllocFailed == true) + { + break; + } + + /* Trans Id */ + arrIdx = 0; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId; + + arrIdx++; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = causeInfo; + if(causeInfo == CauseE2_PR_e2Node) + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.e2Node = causeReason; + else + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.misc = causeReason; + + arrIdx++; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s; + + 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); + + /* Check encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode E2 Node Config Update failure structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node Config Update Failure\n"); + for(int i=0; i< encBufSize; i++) + { + DU_LOG("%x",encBuf[i]); + } + } + + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) + { + DU_LOG("\nERROR --> E2AP : Sending E2 Node Config Update Failure failed"); + break; + } + break; + } + + FreeE2ConfigUpdateFail(e2apMsg); + return ROK; +} + +/******************************************************************* + * + * @brief process the E2 node configuration update + * + * @details + * + * Function : ProcE2NodeConfigUpdate + * + * Functionality: Process E2 node configuration update + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +void ProcE2NodeConfigUpdate(uint32_t duId, E2nodeConfigurationUpdate_t *e2NodeConfigUpdate) +{ + uint8_t ieIdx = 0; + uint8_t transId = 0, e2NodeUpdateListIdx=0; + E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList=NULLP; + E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe=NULLP; + E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULLP; + + if(e2NodeConfigUpdate) + { + if(e2NodeConfigUpdate->protocolIEs.list.array) + { + for(ieIdx=0; ieIdx < e2NodeConfigUpdate->protocolIEs.list.count; ieIdx++) + { + if(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]) + { + switch(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_TransactionID: + transId = e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID; + break; + + default: + { + /*TODO - Other IEs will be handling in next gerrit*/ + break; + } + } + } + } + } + } +} + /******************************************************************* * * @brief Builds Global RIC Id Params @@ -889,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; - ricSubsDb->actionSequence[ricSubsDb->numOfActions].id = \ + 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; @@ -913,7 +1233,8 @@ uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscr return ROK; } - memset(&ricSubsDb->actionSequence[ricSubsDb->numOfActions], 0, sizeof(ActionInfo)); + memset(&ricSubsDb->actionSequence[ricActionId], 0, sizeof(ActionInfo)); + ricSubsDb->actionSequence[ricActionId].actionId = -1; return RFAILED; } @@ -1035,6 +1356,7 @@ uint8_t fillEventTriggerDef(RICeventTriggerDefinition_t *ricEventTriggerDef) uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails, RicSubscription *ricSubsDb) { + uint8_t actionIdx = 0; uint8_t elementCnt = 0; uint8_t elementIdx = 0; @@ -1076,6 +1398,11 @@ uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails, RicSubscripti if(elementIdx < elementCnt) break; + for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++) + { + ricSubsDb->actionSequence[actionIdx].actionId = -1; + } + elementIdx = 0; if(fillActionToBeSetup((RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], \ ricSubsDb) != ROK) @@ -1110,7 +1437,6 @@ uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) RICsubscriptionRequest_t *ricSubscriptionReq; uint8_t elementCnt; uint8_t idx; - uint8_t ieId; asn_enc_rval_t encRetVal; /* Encoder return value */ RanFunction *ranFuncDb = &duDb->ranFunction[0]; @@ -1171,7 +1497,7 @@ uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) if(BuildNewRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID, \ &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription].requestId) != ROK) { - DU_LOG("\nERROR --> E2AP : Failed at [%d] : Line [%d]", __func__, __LINE__); + DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__); break; } @@ -1193,7 +1519,7 @@ uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) if(BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails),\ &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription]) != ROK) { - DU_LOG("\nERROR --> E2AP : Failed at [%d] : Line [%d]", __func__, __LINE__); + DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__); break; } @@ -1250,53 +1576,131 @@ uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) * ******************************************************************/ -void ProcRicSubscriptionResponse(uint32_t duId) +void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp) { - uint8_t duIdx = 0; - DuDb *duDb; + 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; - DU_LOG("\nINFO --> E2AP : RICsubscriptionResponse Msg Acknowledged"); + DU_LOG("\nINFO --> E2AP : RIC Subscription Response received"); + /* Fetch DU DB */ SEARCH_DU_DB(duIdx, duId, duDb); - if(duDb) - duDb->ricSubscribedToDu = true; -} - -/******************************************************************* - * - * @brief deallocate the memory allocated in E2SetupFailure - * - * @details - * - * Function : FreeE2SetupFailure - * - * Functionality: deallocate the memory allocated in E2SetupFailure - * - * @params[in] E2AP_PDU_t *e2apMsg - * - * @return void - * ****************************************************************/ -void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg) -{ - uint8_t arrIdx = 0; - E2setupFailure_t *e2SetupFail; + if(duDb == NULLP) + { + DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); + return; + } - if(e2apMsg) + memset(&ricReqId, 0, sizeof(RicRequestId)); + if(ricSubscriptionRsp) { - if(e2apMsg->choice.unsuccessfulOutcome) + if(ricSubscriptionRsp->protocolIEs.list.array) { - e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure; - if(e2SetupFail->protocolIEs.list.array) + for(ieIdx=0; ieIdxprotocolIEs.list.count; ieIdx++) { - for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]) { - RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t)); - } - RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size); - } - RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t)); - } - RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + ricSubsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx]; + switch(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_RICrequestID: + { + ricReqId.requestorId = ricSubsRspIe->value.choice.RICrequestID.ricRequestorID; + ricReqId.instanceId = ricSubsRspIe->value.choice.RICrequestID.ricInstanceID; + ricReqIdDecoded = true; + break; + } + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsRspIe->value.choice.RANfunctionID; + ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId); + if(!ranFuncDb) + { + DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId); + return; + } + break; + } + case ProtocolIE_IDE2_id_RICactions_Admitted: + { + break; + } + case ProtocolIE_IDE2_id_RICactions_NotAdmitted: + { + if(!(ranFuncDb && ricReqIdDecoded)) + return; + + notAdmitList = &ricSubsRspIe->value.choice.RICaction_NotAdmitted_List; + for(notAdmitIdx = 0; notAdmitIdx < notAdmitList->list.count; notAdmitIdx++) + { + actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\ + value.choice.RICaction_NotAdmitted_Item.ricActionID; + + /* Remove action from RAN Function's subscription list */ + ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb); + if(ricSubs) + { + action = fetchActionInfoFromActionId(actionId, ricSubs); + if(action) + { + memset(action, 0, sizeof(ActionInfo)); + ricSubs->actionSequence[actionId].actionId = -1; + ricSubs->numOfActions--; + } + } + } + break; + } + } + } + } + } + } +} + +/******************************************************************* + * + * @brief deallocate the memory allocated in E2SetupFailure + * + * @details + * + * Function : FreeE2SetupFailure + * + * Functionality: deallocate the memory allocated in E2SetupFailure + * + * @params[in] E2AP_PDU_t *e2apMsg + * + * @return void + * ****************************************************************/ +void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg) +{ + uint8_t arrIdx = 0; + E2setupFailure_t *e2SetupFail; + + if(e2apMsg) + { + if(e2apMsg->choice.unsuccessfulOutcome) + { + e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure; + if(e2SetupFail->protocolIEs.list.array) + { + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + { + RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t)); + } + RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size); + } + RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t)); + } + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); } } @@ -1317,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; @@ -1420,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; } /******************************************************************* @@ -1539,159 +1947,6 @@ uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq) } return ROK; } - -/******************************************************************* - * - * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg - * - * @details - * - * Function : FreeE2NodeConfigUpdate - * - * Functionality: - * - freeing the memory allocated for E2nodeConfigurationUpdate - * - * @params[in] E2AP_PDU_t *e2apMsg - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg) -{ - uint8_t arrIdx =0; - E2nodeConfigurationUpdate_t *e2NodeConfigUpdateAck; - - if(e2apMsg != NULLP) - { - if(e2apMsg->choice.successfulOutcome != NULLP) - { - e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge; - if(e2NodeConfigUpdateAck->protocolIEs.list.array != NULLP) - { - for(arrIdx = 0; arrIdx < e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++) - { - RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_t)); - } - RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size); - } - RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); - } - RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); - } -} - -/******************************************************************* - * - * @brief Buld and send the E2 node config update msg - * - * @details - * - * Function : BuildAndSendE2NodeConfigUpdate - * - * Functionality: - * - Buld and send the E2 node config update msg - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ - -uint8_t BuildAndSendE2NodeConfigUpdateAck(uint32_t duId) -{ - uint8_t arrIdx = 0,elementCnt = 1; - uint8_t ret = ROK; - E2AP_PDU_t *e2apMsg = NULLP; - E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP; - asn_enc_rval_t encRetVal; /* Encoder return value */ - - DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n"); - do - { - RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); - if(e2apMsg == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); - break; - } - e2apMsg->present = E2AP_PDU_PR_successfulOutcome; - RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); - if(e2apMsg->choice.successfulOutcome == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); - RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); - return RFAILED; - } - - e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject; - e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate; - e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge; - e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge; - - e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt; - e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*); - /* Initialize the Ric Indication members */ - RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, \ - e2NodeConfigUpdateAck->protocolIEs.list.size); - if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed"); - break; - } - - for(arrIdx =0; arrIdxprotocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t)); - if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP) - { - - DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed"); - break; - } - } - - arrIdx = 0; - /* TransactionID */ - e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; - e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; - e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID; - e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID; - - - 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 E2 Node config update ack structure (at %s)\n",\ - encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); - return RFAILED; - } - else - { - DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n"); - for(int i=0; i< encBufSize; i++) - { - DU_LOG("%x",encBuf[i]); - } - } - - - /* Sending msg */ - if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) - { - DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack "); - return RFAILED; - } - - break; - }while(true); - - FreeE2NodeConfigUpdateAck(e2apMsg); - return ret; -} - /******************************************************************* * * @brief Deallocate the memory allocated for E2 Reset Response @@ -1772,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; @@ -1818,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 { @@ -1833,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; @@ -1841,7 +2095,7 @@ uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId) }while(true); FreeE2ResetResponse(e2apMsg); - return ROK; + return ret; } /******************************************************************* @@ -1861,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) { @@ -2615,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; @@ -2702,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++; @@ -2738,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--; } @@ -2799,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; @@ -2811,7 +3066,7 @@ uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricS if(duDb == NULLP) { DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); - return; + return RFAILED; } memset(&ricReqId, 0, sizeof(RicRequestId)); @@ -2830,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) { - ranFuncDb = &duDb->ranFunction[ranFuncId-1]; + DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId); + return RFAILED; + } + else + { + /* Remove subscription entry from RAN Function */ + ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb); + if(ricSubs) + { + memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription)); + } } break; } @@ -2846,57 +3111,1083 @@ uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricS default: /* No handling required as of now since this is a stub */ break; - } } } + } + } + return ROK; +} + +/******************************************************************* + * + * @brief Free RIC Subscription Modification Refuse + * + * @details + * + * Function : FreeRicSubsModRefuse + * + * Functionality: Free RIC Subscription Modification Refuse + * + * @param E2AP Message PDU to be freed + * @return void + * + ******************************************************************/ +void FreeRicSubsModRefuse(E2AP_PDU_t *e2apMsg) +{ + uint8_t ieIdx =0; + RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP; - /* Remove subscription entry from RAN Function */ - if(ranFuncDb && ricReqIdDecoded) + if(e2apMsg) + { + if(e2apMsg->choice.unsuccessfulOutcome) + { + ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse; + if(ricSubsModRefuse->protocolIEs.list.array) { - for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++) + for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++) { - if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) && - (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId)) - { - memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription)); - break; - } + RIC_FREE(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t)); } + RIC_FREE(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size); } + RIC_FREE(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t)); } + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); } - return ROK; } /******************************************************************* -* -* @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 Build And Send RIC Subscription Modification Refuse + * + * @details + * + * Function : BuildAndSendRicSubsModRefuse + * + * Functionality: Build And Send RIC Subscription Modification Refuse + * + * @param DU ID + * RIC Request ID of subscription + * RAN Function ID + * Type of failure + * Cause of failure + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t BuildAndSendRicSubsModRefuse(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, CauseE2_PR causeType, \ + uint8_t cause) { - 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"); + uint8_t ieIdx = 0, elementCnt = 0; + uint8_t ret = RFAILED; + E2AP_PDU_t *e2apMsg = NULL; + asn_enc_rval_t encRetVal; + RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP; + RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP; + + DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Refuse\n"); + while(true) + { + RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); + if(e2apMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + break; + } + e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome; + RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t)); + if(e2apMsg->choice.unsuccessfulOutcome == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + break; + } + + e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired; + e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject; + e2apMsg->choice.unsuccessfulOutcome->value.present = \ + UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse; + ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse; + + elementCnt = 3; + ricSubsModRefuse->protocolIEs.list.count = elementCnt; + ricSubsModRefuse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRefuse_IEs_t *); + RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size); + if(!ricSubsModRefuse->protocolIEs.list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + break; + } + + for(ieIdx = 0; ieIdx < elementCnt; ieIdx++) + { + RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t)); + if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + break; + } + } + + /* RIC Request ID */ + ieIdx = 0; + ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx]; + ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RICrequestID; + ricSubsModRefuseIe->criticality = CriticalityE2_reject; + ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RICrequestID; + ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId; + ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId; + + /* RAN Function ID */ + ieIdx++; + ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx]; + ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RANfunctionID; + ricSubsModRefuseIe->criticality = CriticalityE2_reject; + ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RANfunctionID; + ricSubsModRefuseIe->value.choice.RANfunctionID = ranFuncId; + + /* Cause */ + ieIdx++; + ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx]; + ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_CauseE2; + ricSubsModRefuseIe->criticality = CriticalityE2_reject; + ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_CauseE2; + fillE2FailureCause(&ricSubsModRefuseIe->value.choice.CauseE2, causeType, cause); + + 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); + + /* Check encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification refuse (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 refuse\n"); + for(int i=0; i< encBufSize; i++) + { + DU_LOG("%x",encBuf[i]); + } + } + + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Refused"); + break; + } + + ret =ROK; + break; + } + FreeRicSubsModRefuse(e2apMsg); + return ret; +} + +/******************************************************************* + * + * @brief Free memory for RIC Subscription Modification Confirm + * + * @details + * + * Function : FreeRicSubsModConfirm + * + * Functionality: Free memory for RIC subscription modification + * confirm + * + * @param E2AP Message PDU to be freed + * @return Void + * + ******************************************************************/ +void FreeRicSubsModConfirm(E2AP_PDU_t *e2apMsg) +{ + uint8_t ieIdx = 0, arrIdx=0; + RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP; + RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP; + RICactions_ConfirmedForModification_List_t *modCfmList = NULLP; + RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP; + RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP; + RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP; + + if(e2apMsg) + { + if(e2apMsg->choice.successfulOutcome) + { + ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm; + if(ricSubsModCfm->protocolIEs.list.array) + { + for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++) + { + if(ricSubsModCfm->protocolIEs.list.array[ieIdx]) + { + ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx]; + switch(ricSubsModCfmIe->id) + { + case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List: + { + modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List; + if(modCfmList->list.array) + { + for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++) + { + RIC_FREE(modCfmList->list.array[arrIdx], \ + sizeof(RICaction_ConfirmedForModification_ItemIEs_t)); + } + RIC_FREE(modCfmList->list.array, modCfmList->list.size); + } + break; + } + + case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List: + { + modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List; + if(modRefusedList->list.array) + { + for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++) + { + RIC_FREE(modRefusedList->list.array[arrIdx], \ + sizeof(RICaction_RefusedToBeModified_ItemIEs_t)); + } + RIC_FREE(modRefusedList->list.array, modRefusedList->list.size); + } + break; + } + + case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List: + { + rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List; + if(rmvCfmList->list.array) + { + for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++) + { + RIC_FREE(rmvCfmList->list.array[arrIdx], \ + sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t)); + } + RIC_FREE(rmvCfmList->list.array, rmvCfmList->list.size); + } + break; + } + + case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List: + { + rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List; + if(rmvFailList->list.array) + { + for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++) + { + RIC_ALLOC(rmvFailList->list.array[arrIdx], \ + sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t)); + } + RIC_FREE(rmvFailList->list.array, rmvFailList->list.size); + } + break; + } + + default: + break; + + } + RIC_FREE(ricSubsModCfmIe, sizeof(RICsubscriptionModificationConfirm_IEs_t)); + } + } + RIC_FREE(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size); + } + RIC_FREE(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t)); + } + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* + * + * @brief Fill the list of actions confirmed for modification + * + * @details + * + * Function : fillActionModConfirmedList + * + * Functionality: Fill the list of actions confirmed for modification + * + * @param List to be filled + * Number of actions + * Source list of actions + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t fillActionModConfirmedList(RICactions_ConfirmedForModification_List_t *modCfmList, uint8_t numActions, \ + uint8_t *actionModifiedList) +{ + uint8_t arrIdx = 0; + RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP; + + modCfmList->list.count = numActions; + modCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForModification_ItemIEs_t *); + RIC_ALLOC(modCfmList->list.array, modCfmList->list.size); + if(!modCfmList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++) + { + RIC_ALLOC(modCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForModification_ItemIEs_t)); + if(!modCfmList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + return RFAILED; + } + + modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx]; + modCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForModification_Item; + modCfmListItem->criticality = CriticalityE2_ignore; + modCfmListItem->value.present = \ + RICaction_ConfirmedForModification_ItemIEs__value_PR_RICaction_ConfirmedForModification_Item; + modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID = actionModifiedList[arrIdx]; + } + + return ROK; +} + +/******************************************************************* + * + * @brief Fill the list of actions refused to be modified + * + * @details + * + * Function : fillActionModRefusedList + * + * Functionality: Fill the list of actions refused to be modified + * + * @param List to be filled + * Number of list + * Source list of actions refused tobe modified + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t fillActionModRefusedList(RICactions_RefusedToBeModified_List_t *modRefusedList, uint8_t numActions, \ + ActionFailed *actionModFailedList) +{ + uint8_t arrIdx = 0; + RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP; + + modRefusedList->list.count = numActions; + modRefusedList->list.size = numActions * sizeof(RICaction_RefusedToBeModified_ItemIEs_t *); + RIC_ALLOC(modRefusedList->list.array, modRefusedList->list.size); + if(!modRefusedList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++) + { + RIC_ALLOC(modRefusedList->list.array[arrIdx], sizeof(RICaction_RefusedToBeModified_ItemIEs_t)); + if(!modRefusedList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + return RFAILED; + } + + modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx]; + modRefusedListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeModified_Item; + modRefusedListItem->criticality = CriticalityE2_ignore; + modRefusedListItem->value.present = \ + RICaction_RefusedToBeModified_ItemIEs__value_PR_RICaction_RefusedToBeModified_Item; + modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID = \ + actionModFailedList[arrIdx].actionId; + fillE2FailureCause(&modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.cause, \ + actionModFailedList[arrIdx].failureType, actionModFailedList[arrIdx].cause); + } + + return ROK; +} + +/******************************************************************* + * + * @brief Fill the list of action confirmed for removal + * + * @details + * + * Function : fillActionRemovalConfirmedList + * + * Functionality: Fill the list of action confirmed for removal + * + * @param List to be filled + * Number of actions + * Source list of actions removed + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t fillActionRemovalConfirmedList(RICactions_ConfirmedForRemoval_List_t *rmvCfmList, uint8_t numActions, \ + uint8_t *actionRemovedList) +{ + uint8_t arrIdx = 0; + RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP; + + rmvCfmList->list.count = numActions; + rmvCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t *); + RIC_ALLOC(rmvCfmList->list.array, rmvCfmList->list.size); + if(!rmvCfmList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++) + { + RIC_ALLOC(rmvCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t)); + if(!rmvCfmList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + return RFAILED; + } + + rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx]; + rmvCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForRemoval_Item; + rmvCfmListItem->criticality = CriticalityE2_ignore; + rmvCfmListItem->value.present = \ + RICaction_ConfirmedForRemoval_ItemIEs__value_PR_RICaction_ConfirmedForRemoval_Item; + rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID = actionRemovedList[arrIdx]; + } + + return ROK; +} + +/******************************************************************* + * + * @brief Fill the list of actions refused to be removed + * + * @details + * + * Function : fillActionRemovalRefusedList + * + * Functionality: Fill the list of actions refused to be removed + * + * @param List to be filled + * Number of list + * Source list of actions refused to be removed + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t fillActionRemovalRefusedList(RICactions_RefusedToBeRemoved_List_t *rmvFailList, \ + uint8_t numActions, ActionFailed *actionRmvlFailList) +{ + uint8_t arrIdx = 0; + RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP; + + rmvFailList->list.count = numActions; + rmvFailList->list.size = numActions * sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t *); + RIC_ALLOC(rmvFailList->list.array, rmvFailList->list.size); + if(!rmvFailList->list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + return RFAILED; + } + + for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++) + { + RIC_ALLOC(rmvFailList->list.array[arrIdx], sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t)); + if(!rmvFailList->list.array[arrIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + return RFAILED; + } + + rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx]; + rmvFailListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeRemoved_Item; + rmvFailListItem->criticality = CriticalityE2_ignore; + rmvFailListItem->value.present = \ + RICaction_RefusedToBeRemoved_ItemIEs__value_PR_RICaction_RefusedToBeRemoved_Item; + rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID = actionRmvlFailList[arrIdx].actionId; + fillE2FailureCause(&rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.cause, \ + actionRmvlFailList[arrIdx].failureType, actionRmvlFailList[arrIdx].cause); + } + + return ROK; + +} + +/******************************************************************* + * + * @brief Build And Send RIC Subscription Modification Confirm + * + * @details + * + * Function : BuildAndSendRicSubsModConfirm + * + * Functionality: Build And Send RIC Subscription Modification Confirm + * + * @param DU ID + * RIC Request ID of subscription + * RAN Function ID + * Temporary source action list + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t BuildAndSendRicSubsModConfirm(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, RicTmpActionList tmpActionList) +{ + uint8_t ieIdx = 0, elementCnt = 0; + uint8_t ret = RFAILED; + E2AP_PDU_t *e2apMsg = NULLP; + asn_enc_rval_t encRetVal; + RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP; + RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP; + + DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Confirm\n"); + while(true) + { + RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); + if(e2apMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + break; + } + + /* Successful Outcome */ + e2apMsg->present = E2AP_PDU_PR_successfulOutcome; + RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t)); + if(e2apMsg->choice.successfulOutcome == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + break; + } + + e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired; + e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject; + e2apMsg->choice.successfulOutcome->value.present = \ + SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm; + ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm; + + elementCnt = 2; + if(tmpActionList.numActionModified) + elementCnt++; + if(tmpActionList.numActionModFailed) + elementCnt++; + if(tmpActionList.numActionRemoved) + elementCnt++; + if(tmpActionList.numActionRemovalFailed) + elementCnt++; + + ricSubsModCfm->protocolIEs.list.count = elementCnt; + ricSubsModCfm->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationConfirm_IEs_t *); + RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size); + if(!ricSubsModCfm->protocolIEs.list.array) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + break; + } + + for(ieIdx = 0; ieIdx < elementCnt; ieIdx++) + { + RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationConfirm_IEs_t)); + if(!ricSubsModCfm->protocolIEs.list.array[ieIdx]) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__); + break; + } + } + + /* RIC Request ID */ + ieIdx = 0; + ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx]; + ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICrequestID; + ricSubsModCfmIe->criticality = CriticalityE2_reject; + ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RICrequestID; + ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId; + ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId; + + /* RAN Function ID */ + ieIdx++; + ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx]; + ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RANfunctionID; + ricSubsModCfmIe->criticality = CriticalityE2_reject; + ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RANfunctionID; + ricSubsModCfmIe->value.choice.RANfunctionID = ranFuncId; + + /* RIC Actions List confirmed for modification */ + if(tmpActionList.numActionModified) + { + ieIdx++; + ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx]; + ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List; + ricSubsModCfmIe->criticality = CriticalityE2_ignore; + ricSubsModCfmIe->value.present = \ + RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForModification_List; + if(fillActionModConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List, \ + tmpActionList.numActionModified, tmpActionList.actionModifiedList) != ROK) + { + DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Modification List", __func__); + break; + } + } + + /* RIC Actions List refured to be modified */ + if(tmpActionList.numActionModFailed) + { + ieIdx++; + ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx]; + ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List; + ricSubsModCfmIe->criticality = CriticalityE2_ignore; + ricSubsModCfmIe->value.present = \ + RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeModified_List; + if(fillActionModRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List, \ + tmpActionList.numActionModFailed, tmpActionList.actionModFailedList) != ROK) + { + DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Refused to be Modified List", __func__); + break; + } + } + + /* RIC Actions List confirmed for removal */ + if(tmpActionList.numActionRemoved) + { + ieIdx++; + ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx]; + ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List; + ricSubsModCfmIe->criticality = CriticalityE2_ignore; + ricSubsModCfmIe->value.present = \ + RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForRemoval_List; + if(fillActionRemovalConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List, \ + tmpActionList.numActionRemoved, tmpActionList.actionRemovedList) != ROK) + { + DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Removal List", __func__); + break; + } + } + + /* RIC Actions List Refused to be removed */ + if(tmpActionList.numActionRemovalFailed) + { + ieIdx++; + ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx]; + ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List; + ricSubsModCfmIe->criticality = CriticalityE2_ignore; + ricSubsModCfmIe->value.present = \ + RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeRemoved_List; + if(fillActionRemovalRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List, \ + tmpActionList.numActionRemovalFailed, tmpActionList.actionRemovalFailedList) != ROK) + { + DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Failed to be Removed List", __func__); + break; + } + } + + /* Print and encode E2AP Message PDU */ + 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); + + /* Check encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification confirm (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 confirm\n"); + for(int i=0; i< encBufSize; i++) + { + DU_LOG("%x",encBuf[i]); + } + } + + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Confirm"); + break; + } + + ret =ROK; + break; + } + + FreeRicSubsModConfirm(e2apMsg); + return ret; +} + +/******************************************************************* + * + * @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: + { + 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) + { + /* 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_ran_function_id_invalid); + 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_request_id_unknown); + 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.numActionModified++] = actionId; + } + else + { + tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].actionId = actionId; + tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].failureType = \ + CauseE2_PR_ricRequest; + tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].cause = \ + CauseE2RICrequest_action_not_supported; + tmpActionList.numActionModFailed++; + } + } + 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; + ricSubs->numOfActions--; + } + } + break; + } + default: + break; + } + } + + /* If none of the action modification/removal is supported, + * send RIC Subscription Modification Refuse + * Else + * send RIC Subscription Modification Confirm + */ + if(tmpActionList.numActionModified || tmpActionList.numActionRemoved) + { + BuildAndSendRicSubsModConfirm(duId, ricReqId, ranFuncId, tmpActionList); + } + else + { + BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \ + CauseE2RICrequest_action_not_supported); + } + + return ROK; +} + +/******************************************************************* + * + * @brief Free the ErrorIndication Message + * + * @details + * + * Function : FreeRicIndication + * + * Functionality: Free the ErrorIndication Message + * + * @return void + * + * + ******************************************************************/ +void FreeErrorIndication(E2AP_PDU_t *e2apMsg) +{ + uint8_t arrIdx = 0; + ErrorIndicationE2_t *errorIndicationMsg= NULLP; + + if(e2apMsg != NULLP) + { + if(e2apMsg->choice.initiatingMessage != NULLP) + { + errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2; + if(errorIndicationMsg!= NULLP) + { + if(errorIndicationMsg->protocolIEs.list.array != NULLP) + { + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + { + RIC_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t)); + } + RIC_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size); + } + } + RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + } + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + + +/******************************************************************* + * + * @brief Builds and Send the ErrorIndication Message + * + * @details + * + * Function : BuildAndSendErrorIndication + * + * Functionality:Fills the ErrorIndication Message + * + * @params[in] + * DU id + * Trans id + * Ric req id + * Ran function id + * Reason of failure + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t BuildAndSendErrorIndication(uint32_t duId, int8_t transId, RicRequestId requestId, uint16_t ranFuncId, uint8_t reason) +{ + uint8_t elementCnt =0, arrIdx=0, ret = RFAILED; + E2AP_PDU_t *e2apMsg = NULLP; + ErrorIndicationE2_t *errorIndicationMsg=NULLP; + asn_enc_rval_t encRetVal; /* Encoder return value */ + + while(true) + { + DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n"); + + RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); + if(e2apMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__); + break; + } + + e2apMsg->present = E2AP_PDU_PR_initiatingMessage; + RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + if(e2apMsg->choice.initiatingMessage == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__); + break; + } + e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2; + e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; + e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2; + + errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2; + + /* Element count is 2 for TransactionID/RICrequestID and Cause. + * If the RAN function id is present, the count will be increased.*/ + elementCnt = 2; + if(ranFuncId>0) + elementCnt++; + + errorIndicationMsg->protocolIEs.list.count = elementCnt; + errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*); + + /* Initialize the E2Setup members */ + RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size); + if(errorIndicationMsg->protocolIEs.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__); + break; + } + for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++) + { + RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t)); + if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for array Idx %d in %s at line %d",arrIdx,__func__, __LINE__); + break; + } + } + if(arrIdx < elementCnt) + break; + + arrIdx = 0; + + if(transId >=0 && transId<=255) + { + /* TransactionID */ + errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId; + } + else + { + /* RICrequestID */ + errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId; + } + + if(ranFuncId>0) + { + /* RAN Function ID */ + arrIdx++; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId; + } + + /* Cause */ + arrIdx++; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2; + fillE2FailureCause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, CauseE2_PR_misc, reason); + + + /* Prints the Msg formed */ + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\ + encBuf); + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n"); +#ifdef DEBUG_ASN_PRINT + for(int i=0; i< encBufSize; i++) + { + printf("%x",encBuf[i]); + } +#endif + } + + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) + { + DU_LOG("\nINFO --> E2AP : Sending Error Indication Message"); + + } + ret = ROK; + break; + } + FreeErrorIndication(e2apMsg); + return ret; +} + +/******************************************************************* +* +* @brief Handles received E2AP message and sends back response +* +* @details +* +* Function : E2APMsgHdlr +* +* Functionality: +* - Decodes received E2AP control message +* - Prepares response message, encodes and sends to SCTP +* +* @params[in] +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ +void E2APMsgHdlr(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 */ @@ -2950,7 +4241,7 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate: { DU_LOG("\nINFO --> E2AP : E2 node config update received"); - BuildAndSendE2NodeConfigUpdateAck(*duId); + ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate); break; } case InitiatingMessageE2__value_PR_ResetRequestE2: @@ -2961,7 +4252,7 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) } case InitiatingMessageE2__value_PR_RICindication: { - DU_LOG("\nINFO --> E2AP : RIC Indication Acknowledged"); + DU_LOG("\nINFO --> E2AP : RIC Indication received"); break; } case InitiatingMessageE2__value_PR_RICserviceUpdate: @@ -2970,10 +4261,23 @@ 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"); + break; + } default: { - DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]",e2apMsg->choice.initiatingMessage->value.present); + DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \ + e2apMsg->choice.initiatingMessage->value.present); return; } }/* End of switch(initiatingMessage) */ @@ -2985,12 +4289,14 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) { case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse: { - ProcRicSubscriptionResponse(*duId); + ProcRicSubscriptionResponse(*duId, \ + &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse); break; } default: { - DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]",e2apMsg->choice.successfulOutcome->value.present); + DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \ + e2apMsg->choice.successfulOutcome->value.present); return; } break;