*
* @params[in] Action ID
* RIC Subscription DB
+ * Ric Action Node
* @return Action Info DB
* NULL, in case of failure
*
* ****************************************************************/
-ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo)
+ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo, CmLList ** actionNode)
{
ActionInfo *actionInfoDb = NULLP;
- if(ricSubscriptionInfo->actionSequence[actionId].actionId == actionId)
+
+ CM_LLIST_FIRST_NODE(&ricSubscriptionInfo->actionSequence, *actionNode);
+ while(*actionNode)
{
- actionInfoDb = &ricSubscriptionInfo->actionSequence[actionId];
+ actionInfoDb = (ActionInfo*)((*actionNode)->node);
+ if(actionInfoDb && actionInfoDb->actionId == actionId)
+ {
+ break;
+ }
+ *actionNode= (*actionNode)->next;
+ actionInfoDb = NULLP;
}
- else
+
+ if(!actionInfoDb)
{
DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
- subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
- ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
+ subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
+ ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
}
return actionInfoDb;
uint8_t actionIdx = 0, grpIdx = 0, statsIdx = 0;
uint64_t subscriptionId = 0;
ActionInfo *actionDb = NULLP;
+ CmLList *actionNode = NULLP;
ActionDefFormat1 *format1Action = NULLP;
/* Generate subscription ID using RIC Request ID and RAN Function ID */
encodeSubscriptionId(&subscriptionId, ricSubscriptionInfo->ranFuncId, ricSubscriptionInfo->requestId);
macStatsReq->subscriptionId = subscriptionId;
- for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+ CM_LLIST_FIRST_NODE(&ricSubscriptionInfo->actionSequence, actionNode);
+ while(actionNode)
{
- if(ricSubscriptionInfo->actionSequence[actionIdx].action == CONFIG_ADD)
+ actionDb = (ActionInfo*)(actionNode->node);
+ if(actionDb->action == CONFIG_ADD)
{
- actionDb = &ricSubscriptionInfo->actionSequence[actionIdx];
macStatsReq->statsGrpList[grpIdx].groupId = actionDb->actionId;
switch(actionDb->definition.formatType)
{
if(macStatsReq->statsGrpList[grpIdx].numStats)
grpIdx++;
}
+ actionNode = actionNode->next;
}
macStatsReq->numStatsGroup = grpIdx;
uint32_t reportingPeriod = 0;
RanFunction *ranFuncDb = NULLP;
CmLList *ricSubscriptionNode = NULLP;
+ CmLList *actionNode = NULLP;
RicSubscription *ricSubscriptionInfo = NULLP;
ActionInfo *actionInfoDb = NULLP;
PendingSubsRspInfo *pendingSubsRsp = NULLP;
actionInfoDb = NULLP;
actionId = statsRsp->statsGrpAcceptedList[idx];
- actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo);
+ actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode);
if(actionInfoDb && (actionInfoDb->action == CONFIG_ADD))
{
actionInfoDb->action = CONFIG_UNKNOWN;
*/
for(idx=0; idx<statsRsp->numGrpRejected; idx++)
{
+ actionInfoDb = NULLP;
actionId = statsRsp->statsGrpRejectedList[idx].groupId;
- if(ricSubscriptionInfo->actionSequence[actionId].actionId == actionId)
+ actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode);
+ if(actionInfoDb->actionId == actionId)
{
- memset(&ricSubscriptionInfo->actionSequence[actionId], 0, sizeof(ActionInfo));
- ricSubscriptionInfo->numOfActions--;
-
+ deleteActionSequence(actionNode);
pendingSubsRsp->rejectedActionList[pendingSubsRsp->numOfRejectedActions].id = actionId;
convertDuCauseToE2Cause(statsRsp->statsGrpRejectedList[idx].cause, \
&pendingSubsRsp->rejectedActionList[pendingSubsRsp->numOfRejectedActions].failureCause);
uint8_t statsIdx = 0;
RanFunction *ranFuncDb = NULLP;
CmLList *ricSubscriptionNode = NULLP;
+ CmLList *actionNode = NULLP;
RicSubscription *ricSubscriptionInfo = NULLP;
ActionInfo *actionInfo = NULLP;
ActionDefFormat1 *actionFormat = NULLP;
}
/* Fetch RIC subscription's action DB */
- actionInfo = fetchActionInfoFromActionId(statsInd->groupId, ricSubscriptionInfo);
+ actionInfo = fetchActionInfoFromActionId(statsInd->groupId, ricSubscriptionInfo, &actionNode);
if(actionInfo == NULLP)
{
DU_LOG("\nERROR --> E2AP : extractStatsMeasurement: Failed to fetch action ID [%d]", statsInd->groupId);
{
uint8_t actionIdx = 0;
uint32_t reportingPeriod = 0;
+ ActionInfo *action=NULLP;
+ CmLList *actionNode=NULLP;
- for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+ CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
+ while(actionNode)
{
- if(ricSubscription->actionSequence[actionIdx].actionId >= 0)
- {
- BuildAndSendRicIndication(ricSubscription, &ricSubscription->actionSequence[actionIdx]);
- }
+ action = (ActionInfo*)actionNode->node;
+ BuildAndSendRicIndication(ricSubscription, action);
+ actionNode = actionNode->next;
}
/* Start RIC Subscription reporting timer again */
* @return void
*
* ****************************************************************/
-void deleteActionSequence(ActionInfo *action)
+void deleteActionSequence(CmLList *actionNode)
{
+ ActionInfo *action = NULLP;
ActionDefinition *definition=NULLP;
- definition= &action->definition;
- switch(definition->formatType)
+ if(actionNode)
{
- case 1:
- {
- deleteMeasurementInfoList(&definition->choice.format1.measurementInfoList);
- break;
- }
+ action = (ActionInfo*)actionNode->node;
+ definition= &action->definition;
- case 2:
- case 3:
- case 4:
- case 5:
- default:
+ switch(definition->formatType)
{
- DU_LOG("\nERROR --> E2AP : Format %d does not supported", definition->formatType);
- break;
+ case 1:
+ {
+ deleteMeasurementInfoList(&definition->choice.format1.measurementInfoList);
+ break;
+ }
+
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ default:
+ {
+ DU_LOG("\nERROR --> E2AP : Format %d does not supported", definition->formatType);
+ break;
+ }
}
+ memset(action, 0, sizeof(ActionInfo));
+ DU_FREE(actionNode->node, sizeof(ActionInfo));
+ DU_FREE(actionNode, sizeof(CmLList));
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Delete Ric subscription action list
+ *
+ * @details
+ *
+ * Function : deleteActionSequenceList
+ *
+ * Functionality: Delete Ric subscription action list
+ *
+ * @params[in] Action info list
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void deleteActionSequenceList(CmLListCp *actionList)
+{
+ CmLList *actionNode=NULLP;
+
+ CM_LLIST_FIRST_NODE(actionList, actionNode);
+ while(actionNode)
+ {
+ cmLListDelFrm(actionList, actionNode);
+ deleteActionSequence(actionNode);
+ CM_LLIST_FIRST_NODE(actionList, actionNode);
}
- memset(action, 0, sizeof(ActionInfo));
- action->actionId = -1;
+
}
/******************************************************************
* ****************************************************************/
void deleteRicSubscriptionNode(CmLList *subscriptionNode)
{
- uint8_t actionIdx=0;
RicSubscription *ricSubscriptionInfo = NULLP;
ricSubscriptionInfo = (RicSubscription*)subscriptionNode->node;
- for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
- {
- if(ricSubscriptionInfo->actionSequence[actionIdx].actionId > -1)
- {
- deleteActionSequence(&ricSubscriptionInfo->actionSequence[actionIdx]);
- }
- }
-
+ deleteActionSequenceList(&ricSubscriptionInfo->actionSequence);
if(duChkTmr((PTR)ricSubscriptionInfo, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR) == TRUE)
{
duStopTmr((PTR)ricSubscriptionInfo, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR);
RicRequestId requestId;
uint16_t ranFuncId;
EventTriggerDefinition eventTriggerDefinition;
- uint8_t numOfActions;
- ActionInfo actionSequence[MAX_RIC_ACTION];
+ CmLListCp actionSequence;
CmTimer ricSubsReportTimer;
ConfigType action;
E2FailureCause failureCause; /* Used only when a subscription is required to be deleted */
}E2ConnectionList;
uint8_t assignTransactionId();
-ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo);
+ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo, CmLList ** actionNode);
RicSubscription *fetchSubsInfoFromRicReqId(RicRequestId ricReqId, RanFunction *ranFuncDb, CmLList **ricSubscriptionNode);
RanFunction *fetchRanFuncFromRanFuncId(uint16_t ranFuncId);
uint8_t fetchSubsInfoFromSubsId(uint64_t subscriptionId, RanFunction **ranFuncDb, CmLList **ricSubscriptionNode, \
void deleteRicSubscriptionList(CmLListCp *subscriptionList);
void deleteRicSubscriptionNode(CmLList *ricSubscriptionInfo);
void deleteMeasurementInfoList(CmLListCp *measInfoList);
-void deleteActionSequence(ActionInfo *action);
+void deleteActionSequence(CmLList *action);
void deleteMeasuredValueList(CmLListCp *measuredValueList);
void removeE2NodeInformation();
void encodeSubscriptionId(uint64_t *subscriptionId, uint16_t ranFuncId, RicRequestId ricReqId);
return RFAILED;
}
+/*******************************************************************
+ *
+ * @brief add RIC Subs action info
+ *
+ * @details
+ *
+ * Function : addRicSubsAction
+ *
+ * Functionality: add Ric Subs action info
+ *
+ * @parameter
+ * RAN function DB
+ * Pointer to Ric Subc info
+ * Action Sequence list
+ * Procedure Code
+ * E2 Failure Cause
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+CmLList *addRicSubsAction(RanFunction *ranFuncDb, PTR ricSubsInfo, CmLListCp *actionSequence, uint8_t procedureCode, E2FailureCause *failureCause)
+{
+ CmLList *actionNode = NULLP;
+ ActionInfo *actionDb = NULLP;
+ RICactionID_t ricActionID;
+ RICactionType_t ricActionType;
+ RICactionDefinition_t *ricActionDefinition= NULLP;
+ RICaction_ToBeSetup_Item_t *setupItem= NULLP;
+ RICaction_ToBeAddedForModification_Item_t *addIem= NULLP;
+ RICaction_ToBeModifiedForModification_Item_t *modifiedItem= NULLP;
+ RICaction_ToBeRemovedForModification_Item_t *removedItem= NULLP;
+
+ switch(procedureCode)
+ {
+ case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
+ {
+ setupItem = (RICaction_ToBeSetup_Item_t *)ricSubsInfo;
+ ricActionID= setupItem->ricActionID;
+ ricActionType= setupItem->ricActionType;
+ if(setupItem->ricActionDefinition)
+ {
+ ricActionDefinition = setupItem->ricActionDefinition;
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
+ {
+ addIem = (RICaction_ToBeAddedForModification_Item_t*) ricSubsInfo;
+ ricActionID= addIem->ricActionID;
+ ricActionType= addIem->ricActionType;
+ ricActionDefinition = &addIem->ricActionDefinition;
+
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
+ {
+ modifiedItem= (RICaction_ToBeModifiedForModification_Item_t*)ricSubsInfo;
+ ricActionID= modifiedItem->ricActionID;
+ if(modifiedItem->ricActionDefinition)
+ {
+ ricActionDefinition = modifiedItem->ricActionDefinition;
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
+ {
+ removedItem= (RICaction_ToBeRemovedForModification_Item_t*)ricSubsInfo;
+ ricActionID= removedItem->ricActionID;
+ break;
+ }
+ }
+
+
+ DU_ALLOC(actionDb, sizeof(ActionInfo));
+ if(actionDb==NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ return NULLP;
+ }
+ if(ricActionType== RICactionType_report)
+ {
+ actionDb->actionId = ricActionID;
+ actionDb->type = REPORT;
+
+ if(extractRicActionDef(ranFuncDb, &actionDb->definition, ricActionDefinition, failureCause) == ROK)
+ {
+ actionDb->action = CONFIG_ADD;
+ }
+
+ DU_ALLOC(actionNode, sizeof(CmLList));
+ if(actionNode)
+ {
+ actionNode->node = (PTR) actionDb;
+ cmLListAdd2Tail(actionSequence, actionNode);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ DU_FREE(actionDb, sizeof(ActionInfo));
+ return NULLP;
+ }
+ }
+ return actionNode;
+
+}
/*******************************************************************
*
* @brief Extract RIC Action to be setup
uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause, PendingSubsRspInfo *subsRsp)
{
+ CmLList *actionNode = NULLP;
uint8_t actionIdx = 0;
uint8_t ricActionId = 0;
RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
* If RIC action definition's extraction and validation passes,
* Then :
* This action is added to action sequence list of subscription info */
- ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
-
- if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType == RICactionType_report)
+ actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeSetup_Item,\
+ &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item, failureCause);
+
+ if(!actionNode)
{
- ricSubscriptionInfo->actionSequence[ricActionId].actionId = ricActionId;
- ricSubscriptionInfo->actionSequence[ricActionId].type = REPORT;
-
- if(extractRicActionDef(ranFuncDb, &ricSubscriptionInfo->actionSequence[ricActionId].definition, \
- actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, failureCause) == ROK)
+ /* In case of any failure, action is rejected
+ * Added to rejected-action-list in subscription response */
+ subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId;
+ if(failureCause->causeType == E2_NOTHING)
{
- ricSubscriptionInfo->actionSequence[ricActionId].action = CONFIG_ADD;
- ricSubscriptionInfo->numOfActions++;
- break;
+ failureCause->causeType = E2_RIC_REQUEST;
+ failureCause->cause = E2_ACTION_NOT_SUPPORTED;
}
+ memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \
+ failureCause, sizeof(E2FailureCause));
+ subsRsp->numOfRejectedActions++;
}
-
- /* In case of any failure, action is rejected
- * Added to rejected-action-list in subscription response */
- deleteActionSequence(&ricSubscriptionInfo->actionSequence[ricActionId]);
-
- subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId;
- if(failureCause->causeType == E2_NOTHING)
- {
- failureCause->causeType = E2_RIC_REQUEST;
- failureCause->cause = E2_ACTION_NOT_SUPPORTED;
- }
- memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \
- failureCause, sizeof(E2FailureCause));
- subsRsp->numOfRejectedActions++;
break;
}
default:
}
/* If there is even 1 action that can be added, return ROK */
- if(ricSubscriptionInfo->numOfActions)
+ if(ricSubscriptionInfo->actionSequence.count)
return ROK;
if(failureCause->causeType == E2_NOTHING)
* ****************************************************************/
uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg)
{
- uint8_t idx = 0, actionIdx = 0;
+ uint8_t idx = 0;
uint8_t ret = ROK;
uint16_t ranFuncId = 0;
RicRequestId ricReqId;
ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId;
ricSubscriptionInfo->ranFuncId = ranFuncId;
- for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
- {
- ricSubscriptionInfo->actionSequence[actionIdx].actionId = -1;
- }
-
memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
memcpy(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].requestId,
&ricReqId, sizeof(RicRequestId));
* RFAILED - failure
*
******************************************************************/
-uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod, \
- RicSubscription *ricSubscription)
+uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod,\
+ RicSubscription *ricSubscription)
{
- uint8_t arrIdx = 0, actionIdx = 0;
+ uint8_t arrIdx = 0;
+ CmLList *actionNode = NULLP;
+ ActionInfo *actionDb = NULLP;
RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL;
actionToBeModList->list.count = numActionsMod;
}
arrIdx = 0;
- for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+ CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
+ while(actionNode)
{
- if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD)
+ actionDb = (ActionInfo*)(actionNode->node);
+ if(actionDb->action == CONFIG_MOD)
{
DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
if(!actionToBeModList->list.array[arrIdx])
actionToBeMod->value.present = \
RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item;
actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \
- ricSubscription->actionSequence[actionIdx].actionId;
+ actionDb->actionId;
actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms;
arrIdx++;
return ROK;
}
#endif
-
/*******************************************************************
*
* @brief Fill Action required to be removed list
uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \
RicSubscription *ricSubscription)
{
- uint8_t arrIdx = 0, actionIdx = 0;
+ uint8_t arrIdx = 0;
+ CmLList *actionNode = NULLP;
+ ActionInfo *actionDb = NULLP;
RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL;
actionToBeRmvList->list.count = numActionsRmv;
}
arrIdx = 0;
- for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+ CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
+ while(actionNode)
{
- if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL)
+ actionDb = (ActionInfo*)(actionNode->node);
+ if(actionDb->action == CONFIG_DEL)
{
DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
if(!actionToBeRmvList->list.array[arrIdx])
actionToBeRmv->criticality = CriticalityE2_reject;
actionToBeRmv->value.present = \
RICaction_RequiredToBeRemoved_ItemIEs__value_PR_RICaction_RequiredToBeRemoved_Item;
- actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = \
- ricSubscription->actionSequence[actionIdx].actionId;
- fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, \
- ricSubscription->actionSequence[actionIdx].failureCause);
-
+ actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = actionDb->actionId;
+ fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, actionDb->failureCause);
arrIdx++;
}
}
******************************************************************/
uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription)
{
- uint8_t ieIdx = 0, elementCnt=0, actionIdx = 0;
+ ActionInfo * actionDb=NULLP;
+ CmLList *actionNode = NULLP;
+ uint8_t ieIdx = 0, elementCnt=0;
uint8_t numActionsMod = 0, numActionsRmv = 0;
RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
#endif
/* Count number of Actions to be modified or deleted */
- for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+ CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
+ while(actionNode)
{
- if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD)
- numActionsMod++;
- else if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL)
- numActionsRmv++;
+ actionDb = (ActionInfo*)(actionNode->node);
+ if(actionDb->action == CONFIG_MOD)
+ numActionsMod++;
+ else if(actionDb->action == CONFIG_DEL)
+ numActionsRmv++;
+ actionNode = actionNode->next;
}
/* Count number of IEs to be added to messages */
RicRequestId ricReqId;
RanFunction *ranFuncDb = NULLP;
CmLList *ricSubsNode = NULLP;
+ CmLList *actionNode= NULLP;
RicSubscription *ricSubsDb = NULLP;
ActionInfo *actionDb = NULLP;
modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
actionId = modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID;
- actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
+ actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode);
if(!actionDb)
{
DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
{
modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
actionId = modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID;
- actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
+ actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode);
if(!actionDb)
{
DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
{
rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
actionId = rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID;
- actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
+ actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode);
if(!actionDb)
{
DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
}
else
{
- deleteActionSequence(actionDb);
+ deleteActionSequence(actionNode);
actionDb =NULLP;
- ricSubsDb->numOfActions--;
/* Further handling can include :
* Deletion of this action from all DU layers
*/
{
rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
actionId = rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID;
- actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
+ actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb, &actionNode);
if(!actionDb)
{
DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
break;
}
-
+
ricSubsModifyReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
for(ieIdx = 0; ieIdx < ricSubsModifyReq->protocolIEs.list.count; ieIdx++)
{
return currTransId;
}
+ /*******************************************************************
+ *
+ * @brief add RIC Subs action info
+ *
+ * @details
+ *
+ * Function : addRicSubsAction
+ *
+ * Functionality: add Ric Subs action info
+ *
+ * @parameter
+ * RIC action id
+ * List of action
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+CmLList *addRicSubsAction(uint8_t ricActionID, CmLListCp *actionSequence)
+{
+ ActionInfo *actionDb = NULLP;
+ CmLList *actionNode=NULLP;
+
+ RIC_ALLOC(actionDb, sizeof(ActionInfo));
+ if(actionDb==NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ return NULLP;
+ }
+
+ actionDb->actionId = ricActionID;
+ RIC_ALLOC(actionNode, sizeof(CmLList));
+ if(actionNode)
+ {
+ actionNode->node = (PTR) actionDb;
+ cmLListAdd2Tail(actionSequence, actionNode);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__);
+ RIC_FREE(actionDb, sizeof(ActionInfo));
+ return NULLP;
+ }
+
+ return actionNode;
+}
+
/*******************************************************************
*
* @brief Sends E2 msg over SCTP
*
* @params[in] Action ID
* RIC Subscription DB
+ * List of action
* @return Action Info DB
* NULL, in case of failure
*
* ****************************************************************/
-ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo)
+ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo, CmLList ** actionNode)
{
ActionInfo *actionInfoDb = NULLP;
- if(ricSubscriptionInfo->actionSequence[actionId].actionId == actionId)
+
+ CM_LLIST_FIRST_NODE(&ricSubscriptionInfo->actionSequence, *actionNode);
+ while(*actionNode)
{
- actionInfoDb = &ricSubscriptionInfo->actionSequence[actionId];
+ actionInfoDb = (ActionInfo*)((*actionNode)->node);
+ if(actionInfoDb->actionId == actionId)
+ {
+ break;
+ }
+ *actionNode= (*actionNode)->next;
}
- else
+ if(actionInfoDb==NULLP)
{
DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
- subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
- ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
+ subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
+ ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
}
return actionInfoDb;
uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscription *ricSubsDb)
{
static uint8_t ricActionId = 0;
-
+ CmLList *actionNode=NULLP;
if(actionItem == NULLP)
{
DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
/* RIC Action ID */
actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId;
- ricSubsDb->actionSequence[ricActionId].actionId = \
- actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
+ actionNode = addRicSubsAction(ricActionId, &ricSubsDb->actionSequence);
ricActionId++;
/* RIC Action Type */
break;
}
- ricSubsDb->numOfActions++;
return ROK;
}
-
- memset(&ricSubsDb->actionSequence[ricActionId], 0, sizeof(ActionInfo));
- ricSubsDb->actionSequence[ricActionId].actionId = -1;
+
+ if(actionNode)
+ {
+ deleteActionSequence(actionNode);
+ }
return RFAILED;
}
DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
return RFAILED;
}
- for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
- {
- ricSubsInfo->actionSequence[actionIdx].actionId = -1;
- }
while(true)
{
RanFunction *ranFuncDb = NULLP;
RicSubscription *ricSubs = NULLP;
CmLList *ricSubsNode = NULLP;
+ CmLList *actionNode = NULLP;
ActionInfo *action = NULLP;
RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP;
RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
notAdmitList = &ricSubsRspIe->value.choice.RICaction_NotAdmitted_List;
for(notAdmitIdx = 0; notAdmitIdx < notAdmitList->list.count; notAdmitIdx++)
{
+ actionNode=NULLP;
actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\
value.choice.RICaction_NotAdmitted_Item.ricActionID;
ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
if(ricSubs)
{
- action = fetchActionInfoFromActionId(actionId, ricSubs);
+ action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
if(action)
{
- memset(action, 0, sizeof(ActionInfo));
- ricSubs->actionSequence[actionId].actionId = -1;
- ricSubs->numOfActions--;
+ deleteActionSequence(action);
}
}
}
RanFunction *ranFuncDb = NULLP;
RicSubscription *ricSubs = NULLP;
CmLList *ricSubsNode = NULLP;
+ CmLList *actionNode = NULLP;
ActionInfo *action = NULLP;
RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
for(actionIdx = 0; actionIdx < actionToBeModList->list.count; actionIdx++)
{
+ actionNode=NULLP;
actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[actionIdx];
actionId = actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID;
- action = fetchActionInfoFromActionId(actionId, ricSubs);
+ action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
if(action)
{
/* No modification required as of now, hence directly adding to the list */
actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
for(actionIdx = 0; actionIdx < actionToBeRmvList->list.count; actionIdx++)
{
+ actionNode=NULLP;
actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[actionIdx];
actionId = actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID;
- action = fetchActionInfoFromActionId(actionId, ricSubs);
+ action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
if(action)
{
tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId;
- memset(action, 0, sizeof(ActionInfo));
- action->actionId = -1;
- ricSubs->numOfActions--;
+ deleteActionSequence(action);
}
}
break;
return ret;
}
+/******************************************************************
+ *
+ * @brief Delete Ric subscription action
+ *
+ * @details
+ *
+ * Function : deleteActionSequence
+ *
+ * Functionality: Delete Ric subscription action
+ *
+ * @params[in] Action info
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void deleteActionSequence(CmLList *actionNode)
+{
+ ActionInfo *action = NULLP;
+
+ if(actionNode)
+ {
+ action = (ActionInfo*)actionNode->node;
+ memset(action, 0, sizeof(ActionInfo));
+ RIC_FREE(actionNode->node, sizeof(ActionInfo));
+ RIC_FREE(actionNode, sizeof(CmLList));
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Delete Ric subscription action list
+ *
+ * @details
+ *
+ * Function : deleteActionSequenceList
+ *
+ * Functionality: Delete Ric subscription action list
+ *
+ * @params[in] Action info list
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void deleteActionSequenceList(CmLListCp *actionList)
+{
+ CmLList *actionNode=NULLP;
+
+ CM_LLIST_FIRST_NODE(actionList, actionNode);
+ while(actionNode)
+ {
+ cmLListDelFrm(actionList, actionNode);
+ deleteActionSequence(actionNode);
+ CM_LLIST_FIRST_NODE(actionList, actionNode);
+ }
+
+}
+
/******************************************************************
*
* @brief Delete Ric subscription node
RicSubscription *ricSubscriptionInfo = NULLP;
ricSubscriptionInfo = (RicSubscription*)subscriptionNode->node;
-
- for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
- {
- if(ricSubscriptionInfo->actionSequence[actionIdx].actionId > -1)
- {
- memset(&ricSubscriptionInfo->actionSequence[actionIdx], 0, sizeof(ActionInfo));
- }
- }
+
+ deleteActionSequenceList(&ricSubscriptionInfo->actionSequence);
+
memset(ricSubscriptionInfo, 0, sizeof(RicSubscription));
RIC_FREE(subscriptionNode->node, sizeof(RicSubscription));
RIC_FREE(subscriptionNode, sizeof(CmLList));
uint8_t BuildRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *addedActionList, RicSubscription **ricSubsInfo, uint8_t numOfActionToBeAdded, ActionInfo *actionToBeAdded)
{
uint8_t arrIdx=0;
+ CmLList *actionNode=NULLP;
RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe;
addedActionList->list.count = numOfActionToBeAdded;
DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
break;
}
- (*ricSubsInfo)->actionSequence[(*ricSubsInfo)->numOfActions].actionId = (*ricSubsInfo)->numOfActions;
- (*ricSubsInfo)->numOfActions++;
+
+ actionNode = addRicSubsAction((*ricSubsInfo)->actionSequence.count, &(*ricSubsInfo)->actionSequence);
+ if(actionNode == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
}
return ROK;
}
void BuildRicSubsModificationReq(DuDb *duDb, RicSubscription *ricSubsInfo)
{
+ CmLList *actionNode=NULLP;
uint8_t actionToBeAdded =0;
uint8_t actionIdx =0, tmpActionIdx=0;
+ ActionInfo *actionInfoDb = NULLP;
RicSubsModReq ricSubsModReq;
if(ricSubsInfo)
{
memset(&ricSubsModReq, 0, sizeof(RicSubsModReq));
- for(actionIdx=0; actionIdx<ricSubsInfo->numOfActions; actionIdx++)
+
+
+ CM_LLIST_FIRST_NODE(&ricSubsInfo->actionSequence, actionNode);
+ while(actionNode)
{
+ actionInfoDb = (ActionInfo*)(actionNode->node);
/* Change the condition based on the action required to be modiified or removed */
- if(actionIdx%2 == 0)
+ if(((actionInfoDb->actionId)%2) == 0)
{
tmpActionIdx = ricSubsModReq.numOfActionToBeModify;
- ricSubsModReq.actionToBeModify[tmpActionIdx].actionId = ricSubsInfo->actionSequence[actionIdx].actionId;
+ ricSubsModReq.actionToBeModify[tmpActionIdx].actionId = actionInfoDb->actionId;
ricSubsModReq.numOfActionToBeModify++;
}
else
{
tmpActionIdx = ricSubsModReq.numOfActionToBeRemove;
- ricSubsModReq.actionToBeRemove[tmpActionIdx].actionId = ricSubsInfo->actionSequence[actionIdx].actionId;
+ ricSubsModReq.actionToBeRemove[tmpActionIdx].actionId = actionInfoDb->actionId;
ricSubsModReq.numOfActionToBeRemove++;
}
}
/* Change the value of actionToBeAdded based on the number of action required to be added */
actionToBeAdded =1;
- tmpActionIdx = ricSubsInfo->numOfActions;
+ tmpActionIdx = ricSubsInfo->actionSequence.count;
for(actionIdx=0; actionIdx<actionToBeAdded; actionIdx++)
{
ricSubsModReq.actionToBeAdded[actionIdx].actionId = tmpActionIdx;
{
RicRequestId requestId;
uint16_t ranFuncId;
- uint8_t numOfActions;
- ActionInfo actionSequence[MAX_RIC_ACTION];
+ CmLListCp actionSequence;
}RicSubscription;
typedef struct
Code Review / o-du / l2.git / commitdiff