}
return ROK;
}
+
+/*******************************************************************
+ *
+ * @brief Free RIC Subscription Modification Required
+ *
+ * @details
+ *
+ * Function : FreeRicSubsModRequired
+ *
+ * Functionality: Freqq RIC Subscription Modification required
+ *
+ * @param E2AP Message PDU to be freed
+ * @return void
+ *
+ ******************************************************************/
+void FreeRicSubsModRequired(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t ieIdx = 0, arrIdx = 0;
+ RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
+ RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
+ RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
+ RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
+
+ if(e2apMsg)
+ {
+ if(e2apMsg->choice.initiatingMessage)
+ {
+ ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
+ if(ricSubsModReqd->protocolIEs.list.array)
+ {
+ for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
+ {
+ if(ricSubsModReqd->protocolIEs.list.array[ieIdx])
+ {
+ ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
+ switch(ricSubsModReqdIe->id)
+ {
+ case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
+ {
+ actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
+ if(actionToBeModList->list.array)
+ {
+ for(arrIdx = 0; arrIdx < actionToBeModList->list.count; arrIdx++)
+ {
+ DU_FREE(actionToBeModList->list.array[arrIdx], \
+ sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
+ }
+ DU_FREE(actionToBeModList->list.array, actionToBeModList->list.size);
+ }
+ break;
+ }
+
+ case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
+ {
+ actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
+ if(actionToBeRmvList->list.array)
+ {
+ for(arrIdx = 0; arrIdx < actionToBeRmvList->list.count; arrIdx++)
+ {
+ DU_FREE(actionToBeRmvList->list.array[arrIdx], \
+ sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
+ }
+ DU_FREE(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
+ }
+ break;
+ }
+
+ default:
+ break;
+ }
+ DU_FREE(ricSubsModReqd->protocolIEs.list.array[ieIdx], \
+ sizeof(RICsubscriptionModificationRequired_IEs_t));
+ }
+ }
+ DU_FREE(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
+ }
+ DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ }
+ DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fill Action required to be modified list
+ *
+ * @details
+ *
+ * Function : FillActionReqdToBeModList
+ *
+ * Functionality: Fill Action required to be modified list
+ *
+ * @param RIC Actions Required To Be Modified List to be filled
+ * Number of actions to be modified
+ * RIC Subscription DB
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod, \
+ RicSubscription *ricSubscription)
+{
+ uint8_t arrIdx = 0, actionIdx = 0;
+ RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL;
+
+ actionToBeModList->list.count = numActionsMod;
+ actionToBeModList->list.size = numActionsMod * sizeof(RICaction_RequiredToBeModified_ItemIEs_t *);
+ DU_ALLOC(actionToBeModList->list.array, actionToBeModList->list.size);
+ if(!actionToBeModList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ arrIdx = 0;
+ for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+ {
+ if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD)
+ {
+ DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
+ if(!actionToBeModList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+ actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[arrIdx];
+
+ actionToBeMod->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeModified_Item;
+ actionToBeMod->criticality = CriticalityE2_reject;
+ actionToBeMod->value.present = \
+ RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item;
+ actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \
+ ricSubscription->actionSequence[actionIdx].actionId;
+ actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms;
+
+ arrIdx++;
+ }
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill Action required to be removed list
+ *
+ * @details
+ *
+ * Function : FillActionReqdToBeRmvList
+ *
+ * Functionality: Fill Action required to be removed list
+ *
+ * @param RIC Actions Required To Be Removed List to be filled
+ * Number of actions to be removed
+ * RIC Subscription DB
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \
+ RicSubscription *ricSubscription)
+{
+ uint8_t arrIdx = 0, actionIdx = 0;
+ RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL;
+
+ actionToBeRmvList->list.count = numActionsRmv;
+ actionToBeRmvList->list.size = numActionsRmv * sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t *);
+ DU_ALLOC(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
+ if(!actionToBeRmvList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ arrIdx = 0;
+ for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+ {
+ if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL)
+ {
+ DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
+ if(!actionToBeRmvList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+ actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[arrIdx];
+
+ actionToBeRmv->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeRemoved_Item;
+ actionToBeRmv->criticality = CriticalityE2_reject;
+ actionToBeRmv->value.present = \
+ RICaction_RequiredToBeRemoved_ItemIEs__value_PR_RICaction_RequiredToBeRemoved_Item;
+ actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = \
+ ricSubscription->actionSequence[actionIdx].actionId;
+ fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, \
+ ricSubscription->actionSequence[actionIdx].failureCause);
+
+ arrIdx++;
+ }
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill RIC Subscription Modification Required IEs
+ *
+ * @details
+ *
+ * Function : FillRicSubsModRequired
+ *
+ * Functionality: Fill RIC Subscription Modification Required IEs
+ *
+ * @param RIC Subscription Modification Required IEs to be filled
+ * RIC Subscription DB
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription)
+{
+ uint8_t ieIdx = 0, elementCnt=0, actionIdx = 0;
+ uint8_t numActionsMod = 0, numActionsRmv = 0;
+ RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
+ RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
+ RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
+
+ /* Count number of Actions to be modified or deleted */
+ for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+ {
+ if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD)
+ numActionsMod++;
+ else if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL)
+ numActionsRmv++;
+ }
+
+ /* Count number of IEs to be added to messages */
+ elementCnt = 2;
+ if(numActionsMod)
+ elementCnt++;
+ if(numActionsRmv)
+ elementCnt++;
+
+ ricSubsModReqd->protocolIEs.list.count = elementCnt;
+ ricSubsModReqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequired_IEs_t *);
+ DU_ALLOC(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
+ if(!ricSubsModReqd->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
+ {
+ DU_ALLOC(ricSubsModReqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRequired_IEs_t));
+ if(!ricSubsModReqd->protocolIEs.list.array[ieIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+ }
+
+ /* RIC Request ID */
+ ieIdx = 0;
+ ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
+ ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICrequestID;
+ ricSubsModReqdIe->criticality = CriticalityE2_reject;
+ ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RICrequestID;
+ ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID = ricSubscription->requestId.requestorId;
+ ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID = ricSubscription->requestId.instanceId;
+
+ /* RAN Function ID */
+ ieIdx++;
+ ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
+ ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RANfunctionID;
+ ricSubsModReqdIe->criticality = CriticalityE2_reject;
+ ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RANfunctionID;
+ ricSubsModReqdIe->value.choice.RANfunctionID = ricSubscription->ranFuncId;
+
+ /* RIC Actions Required to be Modified */
+ if(numActionsMod)
+ {
+ ieIdx++;
+ ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
+ ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List;
+ ricSubsModReqdIe->criticality = CriticalityE2_reject;
+ ricSubsModReqdIe->value.present = \
+ RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeModified_List;
+ actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
+
+ if(FillActionReqdToBeModList(actionToBeModList, numActionsMod, ricSubscription) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__);
+ return RFAILED;
+ }
+ }
+
+ /* RIC Actions Required to be removed */
+ if(numActionsRmv)
+ {
+ ieIdx++;
+ ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
+ ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List;
+ ricSubsModReqdIe->criticality = CriticalityE2_reject;
+ ricSubsModReqdIe->value.present = \
+ RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeRemoved_List;
+ actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
+
+ if(FillActionReqdToBeRmvList(actionToBeRmvList, numActionsRmv, ricSubscription) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__);
+ return RFAILED;
+ }
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds and Send RIC Subscription Modification Required
+ * message
+ *
+ * @details
+ *
+ * Function : BuildAndSendRicSubsModRequired
+ *
+ * Functionality: Builds and Send RIC Subscription Modification
+ * Required message
+ *
+ * @param RIC Subscription DB
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t BuildAndSendRicSubsModRequired(RicSubscription *ricSubscription)
+{
+ uint8_t ret = RFAILED;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+
+ DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Required \n");
+ while(true)
+ {
+ DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
+ if(e2apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ break;
+ }
+
+ e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
+ DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ if(e2apMsg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
+ break;
+ }
+ e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
+ e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
+ e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired;
+
+ ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
+
+ if(FillRicSubsModRequired(ricSubsModReqd, ricSubscription) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__);
+ break;
+ }
+
+ /* Encode */
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
+
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modifiction Required structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Required \n");
+#ifdef DEBUG_ASN_PRINT
+ for(int i=0; i< encBufSize; i++)
+ {
+ printf("%x",encBuf[i]);
+ }
+#endif
+ }
+ if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Modification Required failed");
+ }
+
+ ret = ROK;
+ break;
+ }
+
+ /* Free RIC Subscription modification required */
+ FreeRicSubsModRequired(e2apMsg);
+ return ret;
+}
+
/*******************************************************************
*
* @brief Handles received E2AP message and sends back response
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
void ProcE2NodeConfigUpdate(uint32_t duId, E2nodeConfigurationUpdate_t *e2NodeConfigUpdate)
{
- uint8_t ieIdx = 0, duIdx = 0;
+ uint8_t ieIdx = 0;
uint8_t transId = 0, e2NodeUpdateListIdx=0;
- DuDb *duDb = NULLP;
E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList=NULLP;
E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe=NULLP;
E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULLP;
actionItem->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
/* RIC Action ID */
- actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId++;
+ actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId;
ricSubsDb->actionSequence[ricActionId].actionId = \
actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
+ ricActionId++;
/* RIC Action Type */
actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report;
void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp)
{
- uint8_t duIdx = 0, ieIdx = 0,subsIdx = 0, notAdmitIdx = 0;
+ uint8_t duIdx = 0, ieIdx = 0, notAdmitIdx = 0;
uint8_t ranFuncId = 0, actionId = 0;
DuDb *duDb = NULLP;
bool ricReqIdDecoded = false;
RicRequestId ricReqId;
RanFunction *ranFuncDb = NULLP;
+ RicSubscription *ricSubs = NULLP;
+ ActionInfo *action = NULLP;
RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP;
RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
case ProtocolIE_IDE2_id_RANfunctionID:
{
ranFuncId = ricSubsRspIe->value.choice.RANfunctionID;
- if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
- {
- ranFuncDb = &duDb->ranFunction[ranFuncId-1];
- }
- else
+ ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
+ if(!ranFuncDb)
{
DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId);
return;
actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\
value.choice.RICaction_NotAdmitted_Item.ricActionID;
- /* Remove action from RAN Function's subscription list */
- for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++)
+ /* Remove action from RAN Function's subscription list */
+ ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb);
+ if(ricSubs)
+ {
+ action = fetchActionInfoFromActionId(actionId, ricSubs);
+ if(action)
{
- if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) &&
- (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId))
- {
- if(ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId].actionId == actionId)
- {
- memset(&ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId], 0, \
- sizeof(ActionInfo));
- ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId].actionId = -1;
- ranFuncDb->subscriptionList[subsIdx].numOfActions--;
- break;
- }
- }
+ memset(action, 0, sizeof(ActionInfo));
+ ricSubs->actionSequence[actionId].actionId = -1;
+ ricSubs->numOfActions--;
}
+ }
}
break;
}
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;
DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
break;
}
+
+ ret = ROK;
break;
}
FreeE2SetupFailure(e2apMsg);
+ return ret;
}
/*******************************************************************
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;
{
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
{
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;
}while(true);
FreeE2ResetResponse(e2apMsg);
- return ROK;
+ return ret;
}
/*******************************************************************
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)
{
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;
{
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++;
{
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--;
}
{
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;
{
ricReqId.requestorId = ricSubsFailIe->value.choice.RICrequestID.ricRequestorID;
ricReqId.instanceId = ricSubsFailIe->value.choice.RICrequestID.ricInstanceID;
- ricReqIdDecoded = true;
break;
}
case ProtocolIE_IDE2_id_RANfunctionID:
{
ranFuncId = ricSubsFailIe->value.choice.RANfunctionID;
- if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
+ ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
+ if(!ranFuncDb)
+ {
+ DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId);
+ return RFAILED;
+ }
+ else
{
- ranFuncDb = &duDb->ranFunction[ranFuncId-1];
+ /* Remove subscription entry from RAN Function */
+ ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb);
+ if(ricSubs)
+ {
+ memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription));
+ }
}
break;
}
default:
/* No handling required as of now since this is a stub */
break;
-
}
}
}
+ }
+ }
+ return ROK;
+}
- /* Remove subscription entry from RAN Function */
- if(ranFuncDb && ricReqIdDecoded)
- {
- for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++)
+/*******************************************************************
+ *
+ * @brief Processing of RIC Subscription Modification Required
+ *
+ * @details
+ *
+ * Function : ProcRicSubsModReqd
+ *
+ * Functionality: Processing of RIC Subscription Modification Required
+ * As of now, we do not identify any scenario where this message
+ * shall be sent by DU. Hence, bare minimum handling has been
+ * done here.
+ *
+ * @param DU ID
+ * RIC Subscription Modification Required IEs
+ * @return ROK-success
+ * RFAILED-failure
+ *
+ ******************************************************************/
+uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t *ricSubsModReqd)
+{
+ uint8_t ieIdx = 0, actionIdx = 0, duIdx = 0;
+ DuDb *duDb = NULLP;
+ uint16_t ranFuncId;
+ uint16_t actionId;
+ RicRequestId ricReqId;
+ RanFunction *ranFuncDb = NULLP;
+ RicSubscription *ricSubs = NULLP;
+ ActionInfo *action = NULLP;
+ RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
+ RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
+ RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
+ RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULLP;
+ RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULLP;
+ RicTmpActionList tmpActionList;
+
+ memset(&ricReqId, 0, sizeof(RicRequestId));
+ memset(&tmpActionList, 0, sizeof(RicTmpActionList));
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ return RFAILED;
+ }
+
+ for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
+ {
+ ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
+ switch(ricSubsModReqdIe->id)
+ {
+ case ProtocolIE_IDE2_id_RICrequestID:
{
- if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) &&
- (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId))
+ ricReqId.requestorId = ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID;
+ ricReqId.instanceId = ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID;
+ break;
+ }
+ case ProtocolIE_IDE2_id_RANfunctionID:
+ {
+ ranFuncId = ricSubsModReqdIe->value.choice.RANfunctionID;
+ ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
+ if(!ranFuncDb)
{
- memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription));
- break;
+ /* If RIC Subscription not found, send RIC Subscription modification refuse to DU */
+ DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RIC Subscription not found");
+ //BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
+ CauseE2RICrequest_request_id_unknown);
+ return RFAILED;
+ }
+
+ ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb);
+ if(!ricSubs)
+ {
+ /* If RAN Function not found, send RIC Subscription modification refuse to DU */
+ DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RAN Function ID [%d] not found",ranFuncId);
+ //BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, \
+ CauseE2_PR_ricRequest, CauseE2RICrequest_ran_function_id_invalid);
+ return RFAILED;
}
+ break;
}
- }
+ case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
+ {
+ actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
+ for(actionIdx = 0; actionIdx < actionToBeModList->list.count; actionIdx++)
+ {
+ actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[actionIdx];
+ actionId = actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID;
+ action = fetchActionInfoFromActionId(actionId, ricSubs);
+ if(action)
+ {
+ /* No modification required as of now, hence directly adding to the list */
+ tmpActionList.actionModifiedList[tmpActionList.numActionModifed++] = actionId;
+ }
+ else
+ {
+ tmpActionList.actionModFailedList[tmpActionList.numActionModFailed++] = actionId;
+ }
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
+ {
+ actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
+ for(actionIdx = 0; actionIdx < actionToBeRmvList->list.count; actionIdx++)
+ {
+ actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[actionIdx];
+ actionId = actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID;
+ action = fetchActionInfoFromActionId(actionId, ricSubs);
+ if(action)
+ {
+ tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId;
+ memset(action, 0, sizeof(ActionInfo));
+ action->actionId = -1;
+ }
+ }
+ break;
+ }
+ default:
+ break;
}
}
+
+ /* If none of the action modification/removal is supported,
+ * send RIC Subscription Modification Refuse
+ * Else
+ * send RIC Subscription Modification Confirm
+ */
+ // TO BE DONE IN FUTURE GERRITS
+ /*
+ if(tmpActionList.numActionModifed || tmpActionList.numActionRemoved)
+ BuildAndSendRicSubsModConfirm(duId, ricReqId, ranFuncId, tmpActionList);
+ else
+ BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
+ CauseE2RICrequest_action_not_supported);
+ */
return ROK;
}
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");
Code Review / o-du / l2.git / commitdiff