#include "du_sctp.h"
#include "du_mgr.h"
#include "du_mgr_main.h"
+#include "du_msg_hdl.h"
#include "du_utils.h"
#include "GlobalE2node-gNB-ID.h"
#include "ProtocolIE-FieldE2.h"
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;
+
+ 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_RICaction_ToBeAddedForModification_Item:
+ {
+ addIem = (RICaction_ToBeAddedForModification_Item_t*) ricSubsInfo;
+ ricActionID= addIem->ricActionID;
+ ricActionType= addIem->ricActionType;
+ ricActionDefinition = &addIem->ricActionDefinition;
+
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item:
+ {
+ modifiedItem= (RICaction_ToBeModifiedForModification_Item_t*)ricSubsInfo;
+ ricActionID= modifiedItem->ricActionID;
+ /* Added since ricActionType IE is not present in case of
+ * modification */
+ ricActionType = RICactionType_report;
+ if(modifiedItem->ricActionDefinition)
+ {
+ ricActionDefinition = modifiedItem->ricActionDefinition;
+ }
+ 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_CONTROL_FAILED_TO_EXECUTE;
}
+ 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, CONFIG_UNKNOWN);
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, CONFIG_UNKNOWN);
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, CONFIG_UNKNOWN);
if(!actionDb)
{
DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
}
else
{
- deleteActionSequence(actionDb);
+ cmLListDelFrm(&ricSubsDb->actionSequence, actionNode);
+ 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, CONFIG_UNKNOWN);
if(!actionDb)
{
DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
ricSubsDelFailureIe->value.choice.RANfunctionID = ranFuncId;
ieIdx++;
+ ricSubsDelFailureIe = ricSubsDelFailure->protocolIEs.list.array[ieIdx];
ricSubsDelFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
ricSubsDelFailureIe->criticality = CriticalityE2_ignore;
ricSubsDelFailureIe->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_CauseE2;
break;
}
- if(BuildAndSendStatsDeleteReq(ricSubsDb) != ROK)
+ if(BuildAndSendStatsDeleteReq(ricSubsDb, true) != ROK)
{
DU_LOG("\nERROR --> E2AP : Failed to build and send ric subscription delete req to du layers");
}
/*******************************************************************
*
- * @brief Handles received E2AP message and sends back response
+ * @brief Free RIC Subscription action to be added list
*
* @details
*
- * Function : E2APMsgHdlr
+ * Function : freeAperDecodingOfRicSubsActionToBeAdded
*
- * Functionality:
- * - Decodes received E2AP control message
- * - Prepares response message, encodes and sends to SCTP
+ * Functionality: Free the RIC Subscription action to be added list
*
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
+ * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
+ * @return void
*
* ****************************************************************/
-void E2APMsgHdlr(Buffer *mBuf)
+void freeAperDecodingOfRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
{
- int i =0;
- char *recvBuf = NULLP;
- MsgLen copyCnt =0;
- MsgLen recvBufLen =0;
- E2AP_PDU_t *e2apMsg = NULLP;
- asn_dec_rval_t rval ={0}; /* Decoder return value */
- E2AP_PDU_t e2apasnmsg={0} ;
-
- DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
- ODU_PRINT_MSG(mBuf, 0,0);
-
- /* Copy mBuf into char array to decode it */
- ODU_GET_MSG_LEN(mBuf, &recvBufLen);
- DU_ALLOC(recvBuf, (Size)recvBufLen);
+ uint8_t elementIdx = 0;
+ RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
- if(recvBuf == NULLP)
+ if(subsDetails->list.array)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation failed");
- return;
- }
- if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
- {
- DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
- return;
+ for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
+ {
+ if(subsDetails->list.array[elementIdx])
+ {
+ addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
+ free(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf);
+ free(subsDetails->list.array[elementIdx]);
+ }
+ }
+ free(subsDetails->list.array);
}
+}
-#ifdef DEBUG_ASN_PRINT
- printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
- for(i=0; i< recvBufLen; i++)
+/*******************************************************************
+ *
+ * @brief Deallocation of memory allocated by aper decoder for
+ * RIC Subscription action to be removed list
+ *
+ * @details
+ *
+ * Function : freeAperDecodingOfRicSubsActionToBeRemoved
+ *
+ * Functionality: Free the RIC Subscription action to be removed list
+ *
+ * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
+ * @return void
+ *
+ * ****************************************************************/
+void freeAperDecodingOfRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
+{
+ uint8_t elementIdx = 0;
+
+ if(subsDetails->list.array)
{
- printf("%x",recvBuf[i]);
+ for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
+ {
+ if(subsDetails->list.array[elementIdx])
+ {
+ free(subsDetails->list.array[elementIdx]);
+ }
+ }
+ free(subsDetails->list.array);
}
-#endif
-
- /* Decoding flat buffer into E2AP messsage */
- e2apMsg = &e2apasnmsg;
- memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
+}
- rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
- DU_FREE(recvBuf, (Size)recvBufLen);
+/*******************************************************************
+ *
+ * @brief Deallocation of memory allocated by aper decoder for
+ * RIC Subscription action to be modify
+ *
+ * @details
+ *
+ * Function : freeAperDecodingOfRicSubsActionToBeModified
+ *
+ * Functionality: Free the RIC Subscription action to be modify
+ *
+ * @params[in] RICactions_ToBeModifiedForModification_List_t List
+ * @return void
+ *
+ * ****************************************************************/
+void freeAperDecodingOfRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
+{
+ uint8_t elementIdx = 0;
+ RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
- if(rval.code == RC_FAIL || rval.code == RC_WMORE)
+ if(subsDetails->list.array)
{
- DU_LOG("\nERROR --> E2AP : ASN decode failed");
- return;
+ for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
+ {
+ if(subsDetails->list.array[elementIdx])
+ {
+ actionItem = (RICaction_ToBeModifiedForModification_ItemIEs_t *)subsDetails->list.array[elementIdx];
+ if(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
+ {
+ free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf);
+ free(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition);
+ }
+ free(subsDetails->list.array[elementIdx]);
+ }
+ }
+ free(subsDetails->list.array);
}
- printf("\n");
- xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
+}
- switch(e2apMsg->present)
+/*******************************************************************
+ *
+ * @brief Deallocation of memory allocated by aper decoder for
+ * RIC Subscription modification Request
+ *
+ * @details
+ *
+ * Function freeAperDecodingOfRicSubsModificationReq
+ *
+ * Functionality : Free RIC Subscription modification Request
+ *
+ * @params[in] E2AP_PDU
+ * @return void
+ *
+ ******************************************************************/
+void freeAperDecodingOfRicSubsModificationReq(E2AP_PDU_t *e2apRicMsg)
+{
+ uint8_t idx = 0;
+ RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
+ RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe;
+
+ ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
+
+ if(ricSubscriptionModReq->protocolIEs.list.array)
{
- case E2AP_PDU_PR_unsuccessfulOutcome:
+ for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
+ {
+ if(ricSubscriptionModReq->protocolIEs.list.array[idx])
{
- switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
+ ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
+
+ switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
{
- case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
- {
- procE2SetupFailure(e2apMsg);
- break;
- }
- case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure:
- {
- procE2NodeConfigUpdateFailure(e2apMsg);
- break;
- }
- case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure:
+ case ProtocolIE_IDE2_id_RICrequestID:
+ break;
+
+ case ProtocolIE_IDE2_id_RANfunctionID:
+ break;
+
+ case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
{
- procRicServiceUpdateFailure(e2apMsg);
+ freeAperDecodingOfRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
break;
}
- case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse:
+ case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
{
- procRicSubscriptionModificationRefuse(e2apMsg);
+ freeAperDecodingOfRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
break;
}
- case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
+ case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
{
- ProcE2RemovalFailure(e2apMsg);
+ freeAperDecodingOfRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
break;
}
default:
{
- DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
- e2apMsg->choice.unsuccessfulOutcome->value.present);
- return;
+ DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
+ break;
}
+
}
- free(e2apMsg->choice.unsuccessfulOutcome);
- break;
+
+ free(ricSubscriptionModReq->protocolIEs.list.array[idx]);
}
- case E2AP_PDU_PR_successfulOutcome:
+ }
+ free(ricSubscriptionModReq->protocolIEs.list.array);
+ }
+}
+/*******************************************************************
+ *
+ * @brief Extract RIC Action to be added
+ *
+ * @details
+ *
+ * Function : extractRicActionToBeAddedForModification
+ *
+ * Functionality : This function :
+ * - [Step -1] Traverse each AddedForModification item indexes.
+ * - [Step -2] Add each action id related information in
+ * RicSubscription Db.
+ * - [Step -3] If failed to store then add action related info in
+ * pending rsp's rejectedActionList.
+ * - [Step -4] Else increment action added count
+ * - [Step -5] If there is even 1 action that can be added,
+ * return ROK, else RFAILED.
+ *
+ * @params[in] RAN Function Database structure
+ * RIC Subscription Info to be added to RAN function
+ * RIC Action To Be AddedForModification List received from RIC
+ * failure Cause
+ * Pending Subs Mod Rsp Info
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t extractRicActionToBeAddedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
+ RICactions_ToBeAddedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
+{
+ uint8_t actionAdded=0;
+ CmLList *actionNode = NULLP;
+ uint8_t actionIdx = 0;
+ uint8_t ricActionId = 0;
+ RICaction_ToBeAddedForModification_ItemIEs_t *actionItem = NULLP;
+
+ if(actionList->list.array)
+ {
+ for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
+ {
+ /* Step -1 */
+ actionItem =(RICaction_ToBeAddedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
+ switch(actionItem->id)
{
- switch(e2apMsg->choice.successfulOutcome->value.present)
- {
- case SuccessfulOutcomeE2__value_PR_E2setupResponse:
+ case ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item:
+ {
+ /* Step -2 */
+ actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeAddedForModification_Item,\
+ &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item, failureCause);
+
+ if(!actionNode)
{
- if(!duCb.e2Status)
+ /* Step -3 */
+ subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].id = ricActionId;
+ if(failureCause->causeType == E2_NOTHING)
{
- procE2SetupRsp(e2apMsg);
+ failureCause->causeType = E2_RIC_REQUEST;
+ failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
}
- break;
- }
- case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
- {
- procResetResponse(e2apMsg);
- break;
+ memcpy(&subsModRsp->addActionStatus.rejectedActionList[subsModRsp->addActionStatus.numOfRejectedActions].failureCause, \
+ failureCause, sizeof(E2FailureCause));
+ subsModRsp->addActionStatus.numOfRejectedActions++;
}
- case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge:
+ else
{
- procRicServiceUpdateAck(e2apMsg);
- break;
+ /* Step -4 */
+ actionAdded++;
}
- case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm:
- {
- procRicSubscriptionModificationConfirm(e2apMsg);
+ break;
+ }
+ default:
+ DU_LOG("\nERROR --> E2AP : Invalid IE received in RicAddedForModificationLst:%ld",actionItem->id);
+ break;
+ }
+ }
+ }
+
+ /* Step -5 */
+ if(actionAdded)
+ return ROK;
+
+ if(failureCause->causeType == E2_NOTHING)
+ {
+ failureCause->causeType = E2_RIC_REQUEST;
+ failureCause->cause = E2_ACTION_NOT_SUPPORTED;
+ }
+ return RFAILED;
+}
+
+/*******************************************************************
+ *
+ * @brief Extract RIC Action to be Modified
+ *
+ * @details
+ *
+ * Function : extractRicActionToBeModifiedForModification
+ *
+ * Functionality : This function :
+ * - [Step -1] Traverse each Modification item indexes.
+ * - [Step -2] Find each action id related information in
+ * RicSubscription Db.
+ * - [Step -3] If not found store the action related info in pending
+ * rsp's action rejected.
+ * - [Step -4] If found store the new node in action seq list.
+ * [Step -4.1] If action failed to store, add the action
+ * info in pending subscription rsp's rejected list.
+ * [Step -4.2] If action stored successfully, change the status
+ * of added action to modified because action added as part of
+ * ric subscription modification req.
+ * - [Step -5] If there is even 1 action that can be modified,
+ * return ROK, else RFAILED.
+ *
+ * @params[in] RAN Function Database structure
+ * RIC Subscription Info to be Modified to RAN function
+ * RIC Action To Be ModifiedForModification List received from RIC
+ * failure Cause
+ * Pending Subs Mod Rsp Info
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t extractRicActionToBeModifiedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
+ RICactions_ToBeModifiedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
+{
+ uint8_t actionId=0;
+ uint8_t actionIdx = 0;
+ uint8_t actionFound=0;
+ CmLList *actionNode = NULLP;
+ ActionInfo *actionDb = NULLP;
+ RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
+
+ if(actionList->list.array)
+ {
+ for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
+ {
+ /* [Step -1] */
+ actionItem =(RICaction_ToBeModifiedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
+ switch(actionItem->id)
+ {
+ case ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item:
+ {
+ /* [Step -2] */
+ actionId=actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID;
+ actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
+ if(!actionNode)
+ {
+ /* [Step -3] */
+ subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionDb->actionId;
+ failureCause->causeType = E2_RIC_REQUEST;
+ failureCause->cause = E2_ACTION_NOT_SUPPORTED;
+ memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \
+ failureCause, sizeof(E2FailureCause));
+ subsModRsp->modActionStatus.numOfRejectedActions++;
+ }
+ else
+ {
+ /* [Step -4] */
+ actionNode = NULLP;
+ actionNode = addRicSubsAction(ranFuncDb, (PTR)&actionItem->value.choice.RICaction_ToBeModifiedForModification_Item,\
+ &ricSubscriptionInfo->actionSequence, ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item, failureCause);
+
+ if(!actionNode)
+ {
+ /* [Step -4.1] */
+ subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].id = actionId;
+ if(failureCause->causeType == E2_NOTHING)
+ {
+ failureCause->causeType = E2_RIC_REQUEST;
+ failureCause->cause = E2_CONTROL_FAILED_TO_EXECUTE;
+ }
+ memcpy(&subsModRsp->modActionStatus.rejectedActionList[subsModRsp->modActionStatus.numOfRejectedActions].failureCause, \
+ failureCause, sizeof(E2FailureCause));
+ subsModRsp->addActionStatus.numOfRejectedActions++;
+ }
+ else
+ {
+ /* [Step -4.2] */
+ actionDb = (ActionInfo*)actionNode->node;
+ actionDb->action=CONFIG_MOD;
+ actionFound++;
+ }
+ break;
+ }
+ break;
+ }
+ default:
+ DU_LOG("\nERROR --> E2AP : Invalid IE received in RicModifiedForModificationLst:%ld",actionItem->id);
+ break;
+ }
+ }
+ }
+
+ /* [Step -5] */
+ if(actionFound)
+ return ROK;
+
+ return RFAILED;
+}
+
+/*******************************************************************
+ *
+ * @brief Extract RIC Action to be Removed
+ *
+ * @details
+ *
+ * Function : extractRicActionToBeRemovedForModification
+ *
+ * Functionality : This function :
+ * - [Step -1] Traverse each RemovedForModification item indexes.
+ * - [Step -2] Find each action id related information in
+ * RicSubscription Db.
+ * - [Step -3] If not found store the action related info in pending
+ * rsp's rejectedActionList.
+ * - [Step -4] If found mark action's status CONFIG_DEL.
+ * - [Step -5] If there is even 1 action that can be Removed,
+ * return ROK, else RFAILED.
+ *
+ * @params[in] RAN Function Database structure
+ * RIC Subscription Info to be Removed to RAN function
+ * RIC Action To Be RemovedForModification List received from RIC
+ * failure Cause
+ * Pending ric subs mod Rsp Info to store failure result
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t extractRicActionToBeRemovedForModification(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
+ RICactions_ToBeRemovedForModification_List_t *actionList, E2FailureCause *failureCause, PendingSubsModRspInfo *subsModRsp)
+{
+ uint8_t actionId=0;
+ uint8_t actionIdx = 0;
+ uint8_t actionFound=0;
+ CmLList *actionNode = NULLP;
+ ActionInfo *actionDb = NULLP;
+ RICaction_ToBeRemovedForModification_ItemIEs_t *actionItem = NULLP;
+
+ if(actionList->list.array)
+ {
+ for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
+ {
+ /* [Step -1] */
+ actionItem =(RICaction_ToBeRemovedForModification_ItemIEs_t *)actionList->list.array[actionIdx];
+ switch(actionItem->id)
+ {
+ case ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item:
+ {
+ /* [Step -2] */
+ actionId = actionItem->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID;
+ actionDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
+ if(!actionNode)
+ {
+ /* [Step -3] */
+ subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].id = actionDb->actionId;
+ if(failureCause->causeType == E2_NOTHING)
+ {
+ failureCause->causeType = E2_RIC_REQUEST;
+ failureCause->cause = E2_ACTION_NOT_SUPPORTED;
+ }
+ memcpy(&subsModRsp->removeActionStatus.rejectedActionList[subsModRsp->removeActionStatus.numOfRejectedActions].failureCause, \
+ failureCause, sizeof(E2FailureCause));
+ subsModRsp->removeActionStatus.numOfRejectedActions++;
+ }
+ else
+ {
+ /* [Step -4] */
+ actionDb->action=CONFIG_DEL;
+ actionFound++;
+ }
+ break;
+ }
+ default:
+ DU_LOG("\nERROR --> E2AP : Invalid IE received in RicRemovedForModificationLst:%ld",actionItem->id);
+ break;
+ }
+ }
+ }
+
+ /* [Step -5] */
+ if(actionFound)
+ return ROK;
+
+ return RFAILED;
+}
+
+/*******************************************************************
+ *
+ * @brief Process RIC Subscription modification request
+ *
+ * @details
+ *
+ * Function : procRicSubscriptionModificationRequest
+ *
+ * Functionality: Process RIC subscription modification request.
+ *
+ * @params[in] E2AP PDU
+ * @return void
+ *
+ ******************************************************************/
+void procRicSubscriptionModificationRequest(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t ieIdx = 0;
+ uint16_t ranFuncId = 0;
+ RicRequestId ricReqId;
+ E2FailureCause failureCause;
+ bool procFailure = false;
+ bool addActionIeProcessed=false;
+ bool modActionIeProcessed =false;
+ bool removeActionIeProcessed =false;
+ CmLList *ricSubsNode = NULLP;
+ RanFunction *ranFuncDb = NULLP;
+ RicSubscription *ricSubsDb = NULLP;
+ RICsubscriptionModificationRequest_t *ricSubsModifyReq = NULLP;
+ RICsubscriptionModificationRequest_IEs_t *ricSubsModifyReqIe = NULLP;
+
+ DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Request", __func__);
+
+ do{
+ if(!e2apMsg)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
+ break;
+ }
+
+ if(!e2apMsg->choice.initiatingMessage)
+ {
+ 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++)
+ {
+ if(!ricSubsModifyReq->protocolIEs.list.array[ieIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
+ break;
+ }
+
+ ricSubsModifyReqIe = ricSubsModifyReq->protocolIEs.list.array[ieIdx];
+ switch(ricSubsModifyReqIe->id)
+ {
+ case ProtocolIE_IDE2_id_RICrequestID:
+ {
+ memset(&ricReqId, 0, sizeof(RicRequestId));
+ ricReqId.requestorId = ricSubsModifyReqIe->value.choice.RICrequestID.ricRequestorID;
+ ricReqId.instanceId = ricSubsModifyReqIe->value.choice.RICrequestID.ricInstanceID;
+ break;
+ }
+
+ case ProtocolIE_IDE2_id_RANfunctionID:
+ {
+ ranFuncId = ricSubsModifyReqIe->value.choice.RANfunctionID;
+ ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
+ if(!ranFuncDb)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
+ procFailure = true;
+ break;
+ }
+
+ ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
+ if(!ricSubsDb)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
+ __func__, ricReqId.requestorId, ricReqId.instanceId);
+ procFailure = true;
+ break;
+ }
+ memset(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp], 0, sizeof(PendingSubsModRspInfo));
+ memcpy(&ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].requestId,
+ &ricReqId, sizeof(RicRequestId));
+ ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp].ranFuncId = ranFuncId;
+
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
+ {
+ if(extractRicActionToBeRemovedForModification(ranFuncDb, ricSubsDb,\
+ &ricSubsModifyReqIe->value.choice.RICactions_ToBeRemovedForModification_List,\
+ &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
+ {
+ removeActionIeProcessed= true;
+ }
+
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
+ {
+ if(extractRicActionToBeModifiedForModification(ranFuncDb, ricSubsDb,\
+ &ricSubsModifyReqIe->value.choice.RICactions_ToBeModifiedForModification_List,\
+ &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
+ {
+ modActionIeProcessed = true;
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
+ {
+ if(extractRicActionToBeAddedForModification(ranFuncDb, ricSubsDb,\
+ &ricSubsModifyReqIe->value.choice.RICactions_ToBeAddedForModification_List,\
+ &failureCause, &ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp]) == ROK)
+ {
+ addActionIeProcessed = true;
+ }
+ break;
+ }
+ default:
+ break;
+ } /* End of switch for Protocol IE Id */
+
+ if(procFailure)
+ break;
+ } /* End of for loop for Protocol IE list */
+
+ break;
+ }while(true);
+
+ if(!removeActionIeProcessed && !addActionIeProcessed && !modActionIeProcessed)
+ {
+ BuildAndSendRicSubscriptionModificationFailure(ranFuncId, ricReqId, failureCause);
+ }
+ else
+ {
+ if(duChkTmr((PTR)ricSubsDb, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR) == true)
+ {
+ duStopTmr((PTR)ricSubsDb, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR);
+ }
+
+ ricSubsDb->action = CONFIG_MOD;
+ ranFuncDb->numPendingSubsModRsp++;
+
+ /*If the remove-action ie is present, send a stats delete request;
+ * otherwise, change removeActionCompleted to true in the pendingSubsModRspInfo. */
+ if(removeActionIeProcessed)
+ {
+ BuildAndSendStatsDeleteReq(ricSubsDb, false);
+ }
+ else
+ {
+ ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].removeActionCompleted = true;
+ }
+
+ /*If the mod-action ie is present, send a stats modification request;
+ * otherwise, change modActionCompleted to true in the pendingSubsModRspInfo. */
+ if(modActionIeProcessed)
+ {
+ BuildAndSendStatsModificationReq(ricSubsDb);
+ }
+ else
+ {
+ ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].modActionCompleted= true;
+ }
+
+ /*If the add-action ie is present, send a stats add request;
+ * otherwise, change addActionCompleted to true in the pendingSubsModRspInfo. */
+ if(addActionIeProcessed)
+ {
+ BuildAndSendStatsReq(ricSubsDb);
+ }
+ else
+ {
+ ranFuncDb->pendingSubsModRspInfo[ranFuncDb->numPendingSubsModRsp-1].addActionCompleted= true;
+ }
+
+ }
+
+ freeAperDecodingOfRicSubsModificationReq(e2apMsg);
+}
+
+/*******************************************************************
+ * @brief Free RIC Subscription Modification Failure Message
+ *
+ * @details
+ *
+ * Function : FreeRicSubscriptionModificationFailure
+ *
+ * Functionality: Free RIC Subscription Modification Failure
+ *
+ * @param E2AP Message PDU
+ * @return void
+ *
+ ******************************************************************/
+void FreeRicSubscriptionModificationFailure(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t ieIdx = 0;
+ RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
+
+ if(e2apMsg)
+ {
+ if(e2apMsg->choice.unsuccessfulOutcome)
+ {
+ ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
+ if(ricSubsModFailure->protocolIEs.list.array)
+ {
+ for(ieIdx = 0; ieIdx < ricSubsModFailure->protocolIEs.list.count; ieIdx++)
+ {
+ DU_FREE(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
+ }
+ DU_FREE(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
+ }
+ DU_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
+ }
+ DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
+ }
+}
+/*******************************************************************
+ *
+ * @brief Builds and Send RIC Subscription Modification Failure
+ *
+ * @details
+ *
+ * Function : BuildAndSendRicSubscriptionModificationFailure
+ *
+ * Functionality: Build and send RIC Subscription Modification Failure.
+ *
+ * @params[in]
+ * Ran Func Id
+ * Ric Req Id
+ * E2 failure cause
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t BuildAndSendRicSubscriptionModificationFailure(uint16_t ranFuncId, RicRequestId requestId, E2FailureCause failureCause)
+{
+ uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ RICsubscriptionModificationFailure_t *ricSubsModFailure = NULLP;
+ RICsubscriptionModificationFailure_IEs_t *ricSubsModFailureIe = NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+
+ while(true)
+ {
+ DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Failure Message\n");
+
+ DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
+ if(e2apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ break;
+ }
+
+ e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
+ DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
+ if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ break;
+ }
+ e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
+ e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
+ e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationFailure;
+
+
+ ricSubsModFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationFailure;
+
+ elementCnt = 3;
+ ricSubsModFailure->protocolIEs.list.count = elementCnt;
+ ricSubsModFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationFailure_IEs_t *);
+
+ DU_ALLOC(ricSubsModFailure->protocolIEs.list.array, ricSubsModFailure->protocolIEs.list.size);
+ if(ricSubsModFailure->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
+ break;
+ }
+
+ for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
+ {
+ DU_ALLOC(ricSubsModFailure->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationFailure_IEs_t));
+ if(ricSubsModFailure->protocolIEs.list.array[ieIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
+ __func__, ieIdx, __LINE__);
+ break;
+ }
+ }
+ if(ieIdx < elementCnt)
+ break;
+
+ ieIdx = 0;
+ ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
+ ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RICrequestID;
+ ricSubsModFailureIe->criticality = CriticalityE2_reject;
+ ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RICrequestID;
+ ricSubsModFailureIe->value.choice.RICrequestID.ricRequestorID= requestId.requestorId;
+ ricSubsModFailureIe->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
+
+ ieIdx++;
+ ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
+ ricSubsModFailureIe->id = ProtocolIE_IDE2_id_RANfunctionID;
+ ricSubsModFailureIe->criticality = CriticalityE2_reject;
+ ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_RANfunctionID;
+ ricSubsModFailureIe->value.choice.RANfunctionID = ranFuncId;
+
+ ieIdx++;
+ ricSubsModFailureIe = ricSubsModFailure->protocolIEs.list.array[ieIdx];
+ ricSubsModFailureIe->id = ProtocolIE_IDE2_id_CauseE2;
+ ricSubsModFailureIe->criticality = CriticalityE2_reject;
+ ricSubsModFailureIe->value.present = RICsubscriptionModificationFailure_IEs__value_PR_CauseE2;
+ fillE2Cause(&ricSubsModFailureIe->value.choice.CauseE2, failureCause);
+
+ /* 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 RIC Subscription Modification Failure Message (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 Failure Message \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 : Failed to send RIC Susbcription Modification Failure Message");
+ break;
+ }
+
+ ret = ROK;
+ break;
+ }
+
+ FreeRicSubscriptionModificationFailure(e2apMsg);
+ return ret;
+}
+
+/*******************************************************************
+ * @brief Free RIC Subscription Modification Response Message
+ *
+ * @details
+ *
+ * Function : FreeRicSubscriptionModificationResponse
+ *
+ * Functionality: Free RIC Subscription Modification Response
+ *
+ * @param E2AP Message PDU
+ * @return void
+ *
+ ******************************************************************/
+void FreeRicSubscriptionModificationResponse(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t ieIdx = 0, elementIdx=0;
+ RICactions_AddedForModification_List_t *actionsAdded = NULLP;
+ RICactions_RemovedForModification_List_t *actionsRemoved = NULLP;
+ RICactions_ModifiedForModification_List_t *actionsModified = NULLP;
+ RICactions_FailedToBeAddedForModification_List_t *actionsFailedToBeAdded = NULLP;
+ RICactions_FailedToBeRemovedForModification_List_t *actionsFailedToBeRemoved = NULLP;
+ RICactions_FailedToBeModifiedForModification_List_t *actionsFailedToBeModified = NULLP;
+
+ RICsubscriptionModificationResponse_t *ricSubsModResponse = NULLP;
+
+ if(e2apMsg)
+ {
+ if(e2apMsg->choice.successfulOutcome)
+ {
+ ricSubsModResponse = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse;
+ if(ricSubsModResponse->protocolIEs.list.array)
+ {
+ for(ieIdx = 0; ieIdx < ricSubsModResponse->protocolIEs.list.count; ieIdx++)
+ {
+ if(ricSubsModResponse->protocolIEs.list.array[ieIdx])
+ {
+ switch(ricSubsModResponse->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_RANfunctionID:
+ case ProtocolIE_IDE2_id_RICrequestID:
+ break;
+ case ProtocolIE_IDE2_id_RICactionsRemovedForModification_List:
+ {
+ actionsRemoved = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_RemovedForModification_List;
+ if(actionsRemoved->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionsRemoved->list.count; elementIdx++)
+ {
+ DU_FREE(actionsRemoved->list.array[elementIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t));
+ }
+ DU_FREE(actionsRemoved->list.array, actionsRemoved->list.size);
+ }
+ break;
+ }
+
+ case ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List:
+ {
+ actionsFailedToBeRemoved = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeRemovedForModification_List;
+ if(actionsFailedToBeRemoved->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionsFailedToBeRemoved->list.count; elementIdx++)
+ {
+ DU_FREE(actionsFailedToBeRemoved->list.array[elementIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t));
+ }
+ DU_FREE(actionsFailedToBeRemoved->list.array, actionsFailedToBeRemoved->list.size);
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsModifiedForModification_List:
+ {
+ actionsModified = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_ModifiedForModification_List;
+ if(actionsModified->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionsModified->list.count; elementIdx++)
+ {
+ DU_FREE(actionsModified->list.array[elementIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t));
+ }
+ DU_FREE(actionsModified->list.array, actionsModified->list.size);
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List:
+ {
+ actionsFailedToBeModified = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeModifiedForModification_List;
+ if(actionsFailedToBeModified->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionsFailedToBeModified->list.count; elementIdx++)
+ {
+ DU_FREE(actionsFailedToBeModified->list.array[elementIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t));
+ }
+ DU_FREE(actionsFailedToBeModified->list.array, actionsFailedToBeModified->list.size);
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsAddedForModification_List:
+ {
+ actionsAdded = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_AddedForModification_List;
+ if(actionsAdded->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionsAdded->list.count; elementIdx++)
+ {
+ DU_FREE(actionsAdded->list.array[elementIdx], sizeof(RICaction_AddedForModification_ItemIEs_t));
+ }
+ DU_FREE(actionsAdded->list.array, actionsAdded->list.size);
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List:
+ {
+ actionsFailedToBeAdded = &ricSubsModResponse->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeAddedForModification_List;
+ if(actionsFailedToBeAdded->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionsFailedToBeAdded->list.count; elementIdx++)
+ {
+ DU_FREE(actionsFailedToBeAdded->list.array[elementIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t));
+ }
+ DU_FREE(actionsFailedToBeAdded->list.array, actionsFailedToBeAdded->list.size);
+ }
+ break;
+ }
+ }
+ DU_FREE(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t));
+ }
+ }
+ DU_FREE(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size);
+ }
+ DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
+ }
+ DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
+ }
+}
+
+/*******************************************************************
+*
+* @brief Build Ric subscription action removed list
+*
+* @details
+*
+* Function : BuildActionRemovedList
+*
+* Functionality: Build Ric subs action removed list
+*
+* @params[in]
+* RICactions_RemovedForModification_List_t to be filled
+* Num Of Action removed
+* Action removed list
+*
+* @return ROK - success
+* RFAILED - failure
+*
+******************************************************************/
+
+uint8_t BuildActionRemovedList(RICactions_RemovedForModification_List_t *removedActionList, uint8_t numOfActionRemoved, uint8_t *actionRemoved)
+{
+ uint8_t arrIdx=0;
+ RICaction_RemovedForModification_ItemIEs_t *removedActionItemIe =NULLP;
+
+ removedActionList->list.count = numOfActionRemoved;
+ removedActionList->list.size = removedActionList->list.count * sizeof(RICaction_RemovedForModification_ItemIEs_t*);
+ DU_ALLOC(removedActionList->list.array, removedActionList->list.size);
+ if(!removedActionList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx< removedActionList->list.count; arrIdx++)
+ {
+ DU_ALLOC(removedActionList->list.array[arrIdx], sizeof(RICaction_RemovedForModification_ItemIEs_t));
+ if(!removedActionList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+ removedActionItemIe = (RICaction_RemovedForModification_ItemIEs_t*)removedActionList->list.array[arrIdx];
+ removedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_RemovedForModification_Item;
+ removedActionItemIe->criticality = CriticalityE2_ignore;
+ removedActionItemIe->value.present = RICaction_RemovedForModification_ItemIEs__value_PR_RICaction_RemovedForModification_Item;
+ removedActionItemIe->value.choice.RICaction_RemovedForModification_Item.ricActionID = actionRemoved[arrIdx];
+ }
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Build Ric subscription action added list
+*
+* @details
+*
+* Function : BuildActionAddedList
+*
+* Functionality: Build Ric subs action added list
+*
+* @params[in]
+* RICactions_AddedForModification_List_t to be filled
+* Num Of Action added
+* Action added list
+*
+* @return ROK - success
+* RFAILED - failure
+*
+******************************************************************/
+
+uint8_t BuildActionAddedList(RICactions_AddedForModification_List_t *addedActionList, uint8_t numOfActionAdded, uint8_t *actionAdded)
+{
+ uint8_t arrIdx=0;
+ RICaction_AddedForModification_ItemIEs_t *addedActionItemIe =NULLP;
+
+ addedActionList->list.count = numOfActionAdded;
+ addedActionList->list.size = addedActionList->list.count * sizeof(RICaction_AddedForModification_ItemIEs_t*);
+ DU_ALLOC(addedActionList->list.array, addedActionList->list.size);
+ if(!addedActionList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx< addedActionList->list.count; arrIdx++)
+ {
+ DU_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_AddedForModification_ItemIEs_t));
+ if(!addedActionList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+ addedActionItemIe = (RICaction_AddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx];
+ addedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_AddedForModification_Item;
+ addedActionItemIe->criticality = CriticalityE2_ignore;
+ addedActionItemIe->value.present = RICaction_AddedForModification_ItemIEs__value_PR_RICaction_AddedForModification_Item;
+ addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID = actionAdded[arrIdx];
+ }
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Build Ric subscription action modified list
+*
+* @details
+*
+* Function : BuildActionModifiedList
+*
+* Functionality: Build Ric subs action modified list
+*
+* @params[in]
+* RICactions_ModifiedForModification_List_t to be filled
+* Num Of Action modified
+* Action modified list
+*
+* @return ROK - success
+* RFAILED - failure
+*
+******************************************************************/
+
+uint8_t BuildActionModifiedList(RICactions_ModifiedForModification_List_t *modifiedActionList, uint8_t numOfActionModified, uint8_t *actionModified)
+{
+ uint8_t arrIdx=0;
+ RICaction_ModifiedForModification_ItemIEs_t *modifiedActionItemIe =NULLP;
+
+ modifiedActionList->list.count = numOfActionModified;
+ modifiedActionList->list.size = modifiedActionList->list.count * sizeof(RICaction_ModifiedForModification_ItemIEs_t*);
+ DU_ALLOC(modifiedActionList->list.array, modifiedActionList->list.size);
+ if(!modifiedActionList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx< modifiedActionList->list.count; arrIdx++)
+ {
+ DU_ALLOC(modifiedActionList->list.array[arrIdx], sizeof(RICaction_ModifiedForModification_ItemIEs_t));
+ if(!modifiedActionList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+ modifiedActionItemIe = (RICaction_ModifiedForModification_ItemIEs_t*)modifiedActionList->list.array[arrIdx];
+ modifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ModifiedForModification_Item;
+ modifiedActionItemIe->criticality = CriticalityE2_ignore;
+ modifiedActionItemIe->value.present = RICaction_ModifiedForModification_ItemIEs__value_PR_RICaction_ModifiedForModification_Item;
+ modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID = actionModified[arrIdx];
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Build Ric subscription action failed to be removed list
+ *
+ * @details
+ *
+ * Function : BuildActionFailedToBeRemovedList
+ *
+ * Functionality: Build Ric subs action failed to be removed list
+ *
+ * @params[in]
+ * RICactions_FailedToBeRemovedForModification_List_t to be filled
+ * Num Of Action failed to be removed
+ * Action failed to be removed list
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t BuildActionFailedToBeRemovedList(RICactions_FailedToBeRemovedForModification_List_t *failedToBeRemovedActionList,\
+uint8_t numOfActionFailedToBeRemoved, RejectedAction *actionFailedToBeRemoved)
+{
+ uint8_t arrIdx=0;
+ RICaction_FailedToBeRemovedForModification_ItemIEs_t *failedToBeRemovedActionItemIe =NULLP;
+
+ failedToBeRemovedActionList->list.count = numOfActionFailedToBeRemoved;
+ failedToBeRemovedActionList->list.size = failedToBeRemovedActionList->list.count * sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t*);
+ DU_ALLOC(failedToBeRemovedActionList->list.array, failedToBeRemovedActionList->list.size);
+ if(!failedToBeRemovedActionList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx< failedToBeRemovedActionList->list.count; arrIdx++)
+ {
+ DU_ALLOC(failedToBeRemovedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeRemovedForModification_ItemIEs_t));
+ if(!failedToBeRemovedActionList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+ failedToBeRemovedActionItemIe = (RICaction_FailedToBeRemovedForModification_ItemIEs_t*)failedToBeRemovedActionList->list.array[arrIdx];
+ failedToBeRemovedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeRemovedForModification_Item;
+ failedToBeRemovedActionItemIe->criticality = CriticalityE2_ignore;
+ failedToBeRemovedActionItemIe->value.present = RICaction_FailedToBeRemovedForModification_ItemIEs__value_PR_RICaction_FailedToBeRemovedForModification_Item;
+ failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID = actionFailedToBeRemoved[arrIdx].id;
+ fillE2Cause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause, actionFailedToBeRemoved[arrIdx].failureCause);
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Build Ric subscription action failed to be modified list
+ *
+ * @details
+ *
+ * Function : BuildActionFailedToBeModifiedList
+ *
+ * Functionality: Build Ric subs action failed to be modified list
+ *
+ * @params[in]
+ * RICactions_FailedToBeModifiedForModification_List_t to be filled
+ * Num Of Action failed to be modified
+ * Action failed to be modified list
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t BuildActionFailedToBeModifiedList(RICactions_FailedToBeModifiedForModification_List_t *failedToBeModifiedActionList,\
+uint8_t numOfActionFailedToBeModified, RejectedAction *actionFailedToBeModified)
+{
+ uint8_t arrIdx=0;
+ RICaction_FailedToBeModifiedForModification_ItemIEs_t *failedToBeModifiedActionItemIe =NULLP;
+
+ failedToBeModifiedActionList->list.count = numOfActionFailedToBeModified;
+ failedToBeModifiedActionList->list.size = failedToBeModifiedActionList->list.count * sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t*);
+ DU_ALLOC(failedToBeModifiedActionList->list.array, failedToBeModifiedActionList->list.size);
+ if(!failedToBeModifiedActionList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx< failedToBeModifiedActionList->list.count; arrIdx++)
+ {
+ DU_ALLOC(failedToBeModifiedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeModifiedForModification_ItemIEs_t));
+ if(!failedToBeModifiedActionList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+ failedToBeModifiedActionItemIe = (RICaction_FailedToBeModifiedForModification_ItemIEs_t*)failedToBeModifiedActionList->list.array[arrIdx];
+ failedToBeModifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeModifiedForModification_Item;
+ failedToBeModifiedActionItemIe->criticality = CriticalityE2_ignore;
+ failedToBeModifiedActionItemIe->value.present = RICaction_FailedToBeModifiedForModification_ItemIEs__value_PR_RICaction_FailedToBeModifiedForModification_Item;
+ failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID = actionFailedToBeModified[arrIdx].id;
+ fillE2Cause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause, actionFailedToBeModified[arrIdx].failureCause);
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Build Ric subscription action failed to be added list
+ *
+ * @details
+ *
+ * Function : BuildActionFailedToBeAddedList
+ *
+ * Functionality: Build Ric subs action failed to be added list
+ *
+ * @params[in]
+ * RICactions_FailedToBeAddedForModification_List_t to be filled
+ * Num Of Action failed to be added
+ * Action failed to be added list
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t BuildActionFailedToBeAddedList(RICactions_FailedToBeAddedForModification_List_t *failedToBeAddedActionList, uint8_t numOfActionFailedToBeAdded, RejectedAction *actionFailedToBeAdded)
+{
+ uint8_t arrIdx=0;
+ RICaction_FailedToBeAddedForModification_ItemIEs_t *failedToBeAddedActionItemIe =NULLP;
+
+ failedToBeAddedActionList->list.count = numOfActionFailedToBeAdded;
+ failedToBeAddedActionList->list.size = failedToBeAddedActionList->list.count * sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t*);
+ DU_ALLOC(failedToBeAddedActionList->list.array, failedToBeAddedActionList->list.size);
+ if(!failedToBeAddedActionList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx< failedToBeAddedActionList->list.count; arrIdx++)
+ {
+ DU_ALLOC(failedToBeAddedActionList->list.array[arrIdx], sizeof(RICaction_FailedToBeAddedForModification_ItemIEs_t));
+ if(!failedToBeAddedActionList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+ failedToBeAddedActionItemIe = (RICaction_FailedToBeAddedForModification_ItemIEs_t*)failedToBeAddedActionList->list.array[arrIdx];
+ failedToBeAddedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_FailedToBeAddedForModification_Item;
+ failedToBeAddedActionItemIe->criticality = CriticalityE2_ignore;
+ failedToBeAddedActionItemIe->value.present = RICaction_FailedToBeAddedForModification_ItemIEs__value_PR_RICaction_FailedToBeAddedForModification_Item;
+ failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.ricActionID = actionFailedToBeAdded[arrIdx].id;
+ fillE2Cause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause, actionFailedToBeAdded[arrIdx].failureCause);
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds and Send RIC Subscription Modification Response
+ *
+ * @details
+ *
+ * Function : BuildAndSendRicSubscriptionModificationResponse
+ *
+ * Functionality: Build and send RIC Subscription Modification Response.
+ *
+ * @params[in]
+ * PendingSubsModRspInfo
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t BuildAndSendRicSubscriptionModificationResponse(PendingSubsModRspInfo *pendingSubsModRsp)
+{
+ uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ RICsubscriptionModificationResponse_t *ricSubsModResponse = NULLP;
+ RICsubscriptionModificationResponse_IEs_t *ricSubsModResponseIe = NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+
+ while(true)
+ {
+ DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Response Message\n");
+
+ DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
+ if(e2apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ break;
+ }
+
+ e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
+ DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
+ if(e2apMsg->choice.successfulOutcome == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
+ break;
+ }
+ e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
+ e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
+ e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationResponse;
+
+
+ ricSubsModResponse = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationResponse;
+
+ elementCnt = 2;
+ if(pendingSubsModRsp->removeActionStatus.numOfAcceptedActions)
+ elementCnt++;
+ if(pendingSubsModRsp->addActionStatus.numOfAcceptedActions)
+ elementCnt++;
+ if(pendingSubsModRsp->modActionStatus.numOfAcceptedActions)
+ elementCnt++;
+ if(pendingSubsModRsp->removeActionStatus.numOfRejectedActions)
+ elementCnt++;
+ if(pendingSubsModRsp->addActionStatus.numOfRejectedActions)
+ elementCnt++;
+ if(pendingSubsModRsp->modActionStatus.numOfRejectedActions)
+ elementCnt++;
+
+ ricSubsModResponse->protocolIEs.list.count = elementCnt;
+ ricSubsModResponse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationResponse_IEs_t *);
+
+ DU_ALLOC(ricSubsModResponse->protocolIEs.list.array, ricSubsModResponse->protocolIEs.list.size);
+ if(ricSubsModResponse->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+
+ for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
+ {
+ DU_ALLOC(ricSubsModResponse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationResponse_IEs_t));
+ if(ricSubsModResponse->protocolIEs.list.array[ieIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+ if(ieIdx < elementCnt)
+ break;
+
+ ieIdx = 0;
+ ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
+ ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICrequestID;
+ ricSubsModResponseIe->criticality = CriticalityE2_reject;
+ ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICrequestID;
+ ricSubsModResponseIe->value.choice.RICrequestID.ricRequestorID= pendingSubsModRsp->requestId.requestorId;
+ ricSubsModResponseIe->value.choice.RICrequestID.ricInstanceID = pendingSubsModRsp->requestId.instanceId;
+
+ ieIdx++;
+ ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
+ ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RANfunctionID;
+ ricSubsModResponseIe->criticality = CriticalityE2_reject;
+ ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RANfunctionID;
+ ricSubsModResponseIe->value.choice.RANfunctionID = pendingSubsModRsp->ranFuncId;
+
+ if(pendingSubsModRsp->removeActionStatus.numOfAcceptedActions)
+ {
+ ieIdx++;
+ ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
+ ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsRemovedForModification_List;
+ ricSubsModResponseIe->criticality = CriticalityE2_ignore;
+ ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_RemovedForModification_List;
+ if(BuildActionRemovedList(&ricSubsModResponseIe->value.choice.RICactions_RemovedForModification_List,\
+ pendingSubsModRsp->removeActionStatus.numOfAcceptedActions, pendingSubsModRsp->removeActionStatus.acceptedActionList) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+
+ if(pendingSubsModRsp->removeActionStatus.numOfRejectedActions)
+ {
+ ieIdx++;
+ ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
+ ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List;
+ ricSubsModResponseIe->criticality = CriticalityE2_ignore;
+ ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeRemovedForModification_List;
+ if(BuildActionFailedToBeRemovedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeRemovedForModification_List,\
+ pendingSubsModRsp->removeActionStatus.numOfRejectedActions, pendingSubsModRsp->removeActionStatus.rejectedActionList) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+
+ if(pendingSubsModRsp->modActionStatus.numOfAcceptedActions)
+ {
+ ieIdx++;
+ ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
+ ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsModifiedForModification_List;
+ ricSubsModResponseIe->criticality = CriticalityE2_ignore;
+ ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_ModifiedForModification_List;
+ if(BuildActionModifiedList(&ricSubsModResponseIe->value.choice.RICactions_ModifiedForModification_List,\
+ pendingSubsModRsp->modActionStatus.numOfAcceptedActions, pendingSubsModRsp->modActionStatus.acceptedActionList) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+
+ if(pendingSubsModRsp->modActionStatus.numOfRejectedActions)
+ {
+ ieIdx++;
+ ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
+ ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List;
+ ricSubsModResponseIe->criticality = CriticalityE2_ignore;
+ ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeModifiedForModification_List;
+ if(BuildActionFailedToBeModifiedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeModifiedForModification_List,\
+ pendingSubsModRsp->modActionStatus.numOfRejectedActions, pendingSubsModRsp->modActionStatus.rejectedActionList) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+
+ if(pendingSubsModRsp->addActionStatus.numOfAcceptedActions)
+ {
+ ieIdx++;
+ ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
+ ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsAddedForModification_List;
+ ricSubsModResponseIe->criticality = CriticalityE2_ignore;
+ ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_AddedForModification_List;
+ if(BuildActionAddedList(&ricSubsModResponseIe->value.choice.RICactions_AddedForModification_List,\
+ pendingSubsModRsp->addActionStatus.numOfAcceptedActions, pendingSubsModRsp->addActionStatus.acceptedActionList) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+
+ if(pendingSubsModRsp->addActionStatus.numOfRejectedActions)
+ {
+ ieIdx++;
+ ricSubsModResponseIe = ricSubsModResponse->protocolIEs.list.array[ieIdx];
+ ricSubsModResponseIe->id = ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List;
+ ricSubsModResponseIe->criticality = CriticalityE2_ignore;
+ ricSubsModResponseIe->value.present = RICsubscriptionModificationResponse_IEs__value_PR_RICactions_FailedToBeAddedForModification_List;
+ if(BuildActionFailedToBeAddedList(&ricSubsModResponseIe->value.choice.RICactions_FailedToBeAddedForModification_List,\
+ pendingSubsModRsp->addActionStatus.numOfRejectedActions, pendingSubsModRsp->addActionStatus.rejectedActionList) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+
+ /* 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 RIC Subscription Modification Response Message (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 Response Message \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 : Failed to send RIC Susbcription Modification Response Message");
+ break;
+ }
+
+ ret = ROK;
+ break;
+ }
+
+ FreeRicSubscriptionModificationResponse(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(Buffer *mBuf)
+{
+ int i =0;
+ char *recvBuf = NULLP;
+ MsgLen copyCnt =0;
+ MsgLen recvBufLen =0;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ asn_dec_rval_t rval ={0}; /* Decoder return value */
+ E2AP_PDU_t e2apasnmsg={0} ;
+
+ DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
+ ODU_PRINT_MSG(mBuf, 0,0);
+
+ /* Copy mBuf into char array to decode it */
+ ODU_GET_MSG_LEN(mBuf, &recvBufLen);
+ DU_ALLOC(recvBuf, (Size)recvBufLen);
+
+ if(recvBuf == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed");
+ return;
+ }
+ if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
+ return;
+ }
+
+#ifdef DEBUG_ASN_PRINT
+ printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
+ for(i=0; i< recvBufLen; i++)
+ {
+ printf("%x",recvBuf[i]);
+ }
+#endif
+
+ /* Decoding flat buffer into E2AP messsage */
+ e2apMsg = &e2apasnmsg;
+ memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
+
+ rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
+ DU_FREE(recvBuf, (Size)recvBufLen);
+
+ if(rval.code == RC_FAIL || rval.code == RC_WMORE)
+ {
+ DU_LOG("\nERROR --> E2AP : ASN decode failed");
+ return;
+ }
+ printf("\n");
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
+
+ switch(e2apMsg->present)
+ {
+ case E2AP_PDU_PR_unsuccessfulOutcome:
+ {
+ switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
+ {
+ case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
+ {
+ procE2SetupFailure(e2apMsg);
+ break;
+ }
+ case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure:
+ {
+ procE2NodeConfigUpdateFailure(e2apMsg);
+ break;
+ }
+ case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure:
+ {
+ procRicServiceUpdateFailure(e2apMsg);
+ break;
+ }
+ case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse:
+ {
+ procRicSubscriptionModificationRefuse(e2apMsg);
+ break;
+ }
+ case UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure:
+ {
+ ProcE2RemovalFailure(e2apMsg);
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
+ e2apMsg->choice.unsuccessfulOutcome->value.present);
+ return;
+ }
+ }
+ free(e2apMsg->choice.unsuccessfulOutcome);
+ break;
+ }
+ case E2AP_PDU_PR_successfulOutcome:
+ {
+ switch(e2apMsg->choice.successfulOutcome->value.present)
+ {
+ case SuccessfulOutcomeE2__value_PR_E2setupResponse:
+ {
+ if(!duCb.e2Status)
+ {
+ procE2SetupRsp(e2apMsg);
+ }
+ break;
+ }
+ case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
+ {
+ procResetResponse(e2apMsg);
+ break;
+ }
+ case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge:
+ {
+ procRicServiceUpdateAck(e2apMsg);
+ break;
+ }
+ case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm:
+ {
+ procRicSubscriptionModificationConfirm(e2apMsg);
break;
}
case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
procE2ConnectionUpdate(e2apMsg);
break;
}
+ case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest:
+ {
+ DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Request received");
+ procRicSubscriptionModificationRequest(e2apMsg);
+ break;
+ }
default:
{
DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
Code Review / o-du / l2.git / blobdiff