if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
{
ODU_PRINT_MSG(mBuf, 0,0);
-
+
if(sctpSend(duId, mBuf) != ROK)
{
DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
return RFAILED;
}
-
+
return ROK;
} /* SendE2APMsg */
+/*******************************************************************
+ *
+ * @brief Fetches RAN Function DB
+ *
+ * @details
+ *
+ * Function : fetchRanFuncFromRanFuncId
+ *
+ * Functionality: Fetches RAN function DB from E2AP DB using
+ * RAN function ID
+ *
+ * @params[in] RAN Function ID
+ * @return RAN Function DB
+ * NULL, in case of failure
+ *
+ * ****************************************************************/
+RanFunction *fetchRanFuncFromRanFuncId(DuDb *duDb, uint16_t ranFuncId)
+{
+ RanFunction *ranFuncDb = NULLP;
+
+ /* Fetch RAN Function DB */
+ if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
+ {
+ ranFuncDb = &duDb->ranFunction[ranFuncId-1];
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId);
+ }
+
+ return ranFuncDb;
+}
+
+/*******************************************************************
+ *
+ * @brief Fetch subscripton DB
+ *
+ * @details
+ *
+ * Function : fetchSubsInfoFromRicReqId
+ *
+ * Functionality: Fetches subscription DB from RAN Function DB
+ * using RIC Request ID
+ *
+ * @params[in] RIC Request ID
+ * RAN Function DB
+ * Pointer to RIC Subscription node to be searched
+ * @return RIC Subscription from RAN Function's subcription list
+ * NULL, in case of failure
+ *
+ * ****************************************************************/
+RicSubscription *fetchSubsInfoFromRicReqId(RicRequestId ricReqId, RanFunction *ranFuncDb)
+{
+ uint8_t subsIdx = 0;
+ RicSubscription *ricSubscriptionInfo = NULLP;
+
+ for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++)
+ {
+ if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) &&
+ (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId))
+ {
+ ricSubscriptionInfo = &ranFuncDb->subscriptionList[subsIdx];
+ break;
+ }
+ }
+ return ricSubscriptionInfo;
+}
+
+/*******************************************************************
+ *
+ * @brief Fetch Action details
+ *
+ * @details
+ *
+ * Function : fetchActionInfoFromActionId
+ *
+ * Functionality: Fetch action details from RIC subscription DB
+ * using action ID
+ *
+ * @params[in] Action ID
+ * RIC Subscription DB
+ * @return Action Info DB
+ * NULL, in case of failure
+ *
+ * ****************************************************************/
+ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo)
+{
+ ActionInfo *actionInfoDb = NULLP;
+ if(ricSubscriptionInfo->actionSequence[actionId].actionId == actionId)
+ {
+ actionInfoDb = &ricSubscriptionInfo->actionSequence[actionId];
+ }
+ else
+ {
+ DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
+ subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
+ ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
+
+ }
+ return actionInfoDb;
+}
+
+/*******************************************************************
+ *
+ * @brief deallocate memory allocated in E2 Node Config Update Failure
+ *
+ * @details
+ *
+ * Function : FreeE2ConfigUpdateFail
+ *
+ * Functionality: deallocate memory allocated in E2 Node Config Update Failure
+ *
+ * @params[in] E2AP_PDU_t *e2apMsg
+ *
+ * @return void
+ * ****************************************************************/
+
+void FreeE2ConfigUpdateFail(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t arrIdx = 0;
+ E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
+
+ if(e2apMsg)
+ {
+ if(e2apMsg->choice.unsuccessfulOutcome)
+ {
+ e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
+ if(e2NodeCfgUpdFail->protocolIEs.list.array)
+ {
+ for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
+ {
+ RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateFailure_IEs_t));
+ }
+ RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array, e2NodeCfgUpdFail->protocolIEs.list.size);
+ }
+ RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
+ }
+ RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Buld and send the E2 Node Config Update failure
+ *
+ * @details
+ *
+ * Function : BuildAndSendE2NodeConfigUpdateFailure
+ *
+ * Functionality:
+ * - Buld and send the E2 Node Config Update failure
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t BuildAndSendE2NodeConfigUpdateFailure(uint32_t duId, uint8_t transId, uint8_t causeInfo, uint8_t causeReason)
+{
+ E2AP_PDU_t *e2apMsg = NULL;
+ asn_enc_rval_t encRetVal;
+ uint8_t arrIdx=0;
+ uint8_t elementCnt=0;
+ bool memAllocFailed = false;
+ E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdateFail=NULL;
+
+ DU_LOG("\nINFO --> E2AP : Building E2 Node Config Update failure\n");
+ while(true)
+ {
+ RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
+ if(e2apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ break;
+ }
+ e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
+ RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
+ if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ break;
+ }
+
+ e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
+ e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
+ e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure;
+ e2NodeCfgUpdateFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
+
+ elementCnt = 3;
+ e2NodeCfgUpdateFail->protocolIEs.list.count = elementCnt;
+ e2NodeCfgUpdateFail->protocolIEs.list.size = elementCnt * sizeof(struct E2nodeConfigurationUpdateFailure_IEs *);
+
+ RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array, e2NodeCfgUpdateFail->protocolIEs.list.size);
+ if(e2NodeCfgUpdateFail->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure array failed");
+ break;
+ }
+
+ for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
+ {
+ RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx], sizeof(struct E2nodeConfigurationUpdateFailure_IEs));
+ if(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure IEs failed");
+ memAllocFailed = true;
+ break;
+ }
+ }
+
+ if(memAllocFailed == true)
+ {
+ break;
+ }
+
+ /* Trans Id */
+ arrIdx = 0;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
+
+ arrIdx++;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = causeInfo;
+ if(causeInfo == CauseE2_PR_e2Node)
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.e2Node = causeReason;
+ else
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.misc = causeReason;
+
+ arrIdx++;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
+ e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
+
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
+
+ /* Check encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> E2AP : Could not encode E2 Node Config Update failure structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node Config Update Failure\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Sending E2 Node Config Update Failure failed");
+ break;
+ }
+ break;
+ }
+
+ FreeE2ConfigUpdateFail(e2apMsg);
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief process the E2 node configuration update
+ *
+ * @details
+ *
+ * Function : ProcE2NodeConfigUpdate
+ *
+ * Functionality: Process E2 node configuration update
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+void ProcE2NodeConfigUpdate(uint32_t duId, E2nodeConfigurationUpdate_t *e2NodeConfigUpdate)
+{
+ uint8_t ieIdx = 0;
+ uint8_t transId = 0, e2NodeUpdateListIdx=0;
+ E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList=NULLP;
+ E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe=NULLP;
+ E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULLP;
+
+ if(e2NodeConfigUpdate)
+ {
+ if(e2NodeConfigUpdate->protocolIEs.list.array)
+ {
+ for(ieIdx=0; ieIdx < e2NodeConfigUpdate->protocolIEs.list.count; ieIdx++)
+ {
+ if(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx])
+ {
+ switch(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_TransactionID:
+ transId = e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
+ break;
+
+ default:
+ {
+ /*TODO - Other IEs will be handling in next gerrit*/
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
/*******************************************************************
*
* @brief Builds Global RIC Id Params
actionItem->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
/* RIC Action ID */
- actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ++ricActionId;
- ricSubsDb->actionSequence[ricActionId-1].id = \
+ actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId;
+ ricSubsDb->actionSequence[ricActionId].actionId = \
actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
+ ricActionId++;
/* RIC Action Type */
actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report;
return ROK;
}
- memset(&ricSubsDb->actionSequence[ricActionId-1], 0, sizeof(ActionInfo));
+ memset(&ricSubsDb->actionSequence[ricActionId], 0, sizeof(ActionInfo));
+ ricSubsDb->actionSequence[ricActionId].actionId = -1;
return RFAILED;
}
uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails, RicSubscription *ricSubsDb)
{
+ uint8_t actionIdx = 0;
uint8_t elementCnt = 0;
uint8_t elementIdx = 0;
if(elementIdx < elementCnt)
break;
+ for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+ {
+ ricSubsDb->actionSequence[actionIdx].actionId = -1;
+ }
+
elementIdx = 0;
if(fillActionToBeSetup((RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], \
ricSubsDb) != ROK)
void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp)
{
- uint8_t duIdx = 0, ieIdx = 0,subsIdx = 0, notAdmitIdx = 0;
+ uint8_t duIdx = 0, ieIdx = 0, notAdmitIdx = 0;
uint8_t ranFuncId = 0, actionId = 0;
DuDb *duDb = NULLP;
bool ricReqIdDecoded = false;
RicRequestId ricReqId;
RanFunction *ranFuncDb = NULLP;
+ RicSubscription *ricSubs = NULLP;
+ ActionInfo *action = NULLP;
RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP;
RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
case ProtocolIE_IDE2_id_RANfunctionID:
{
ranFuncId = ricSubsRspIe->value.choice.RANfunctionID;
- if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
- {
- ranFuncDb = &duDb->ranFunction[ranFuncId-1];
- }
- else
+ ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
+ if(!ranFuncDb)
{
DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId);
return;
actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\
value.choice.RICaction_NotAdmitted_Item.ricActionID;
- /* Remove action from RAN Function's subscription list */
- for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++)
+ /* Remove action from RAN Function's subscription list */
+ ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb);
+ if(ricSubs)
+ {
+ action = fetchActionInfoFromActionId(actionId, ricSubs);
+ if(action)
{
- if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) &&
- (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId))
- {
- if(ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId-1].id == actionId)
- {
- memset(&ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId-1], 0, \
- sizeof(ActionInfo));
- ranFuncDb->subscriptionList[subsIdx].numOfActions--;
- break;
- }
- }
+ memset(action, 0, sizeof(ActionInfo));
+ ricSubs->actionSequence[actionId].actionId = -1;
+ ricSubs->numOfActions--;
}
+ }
}
break;
}
uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId)
{
+ uint8_t ret = RFAILED;
E2AP_PDU_t *e2apMsg = NULL;
E2setupFailure_t *e2SetupFailure;
asn_enc_rval_t encRetVal;
DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
break;
}
+
+ ret = ROK;
break;
}
FreeE2SetupFailure(e2apMsg);
+ return ret;
}
/*******************************************************************
}
return ROK;
}
-
/*******************************************************************
*
- * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
+ * @brief Deallocate the memory allocated for E2 Reset Response
*
* @details
*
- * Function : FreeE2NodeConfigUpdate
+ * Function : FreeE2ResetResponse
*
* Functionality:
- * - freeing the memory allocated for E2nodeConfigurationUpdate
+ * - freeing the memory allocated for E2ResetResponse
*
- * @params[in] E2AP_PDU_t *e2apMsg
+ * @params[in] E2AP_PDU_t *e2apMsg
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
+void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
{
- uint8_t arrIdx =0;
- E2nodeConfigurationUpdate_t *e2NodeConfigUpdateAck;
+ uint8_t ieIdx =0;
+ ResetResponseE2_t *resetResponse =NULLP;
if(e2apMsg != NULLP)
{
if(e2apMsg->choice.successfulOutcome != NULLP)
{
- e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
- if(e2NodeConfigUpdateAck->protocolIEs.list.array != NULLP)
+ resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
+ if(resetResponse->protocolIEs.list.array)
{
- for(arrIdx = 0; arrIdx < e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
+ for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
{
- RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_t));
+ if(resetResponse->protocolIEs.list.array[ieIdx])
+ {
+ RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
+ }
}
- RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
+ RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
}
RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
}
/*******************************************************************
*
- * @brief Buld and send the E2 node config update msg
+ * @brief Buld and send the Reset Response msg
*
* @details
*
- * Function : BuildAndSendE2NodeConfigUpdate
+ * Function : BuildAndSendResetResponse
*
* Functionality:
- * - Buld and send the E2 node config update msg
+ * - Buld and send the Reset Response Message
+ *
+ * @params[in]
+ * DU id
+ * TransId Id
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-
-uint8_t BuildAndSendE2NodeConfigUpdateAck(uint32_t duId)
+uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId)
{
- uint8_t arrIdx = 0,elementCnt = 1;
- uint8_t ret = ROK;
+ uint8_t ieIdx = 0, elementCnt = 0;
+ uint8_t ret = RFAILED;
E2AP_PDU_t *e2apMsg = NULLP;
- E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
- asn_enc_rval_t encRetVal; /* Encoder return value */
+ ResetResponseE2_t *resetResponse=NULL;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
- DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
+ DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
do
{
RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
if(e2apMsg == NULLP)
{
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
break;
}
e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
- RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
- if(e2apMsg->choice.successfulOutcome == NULLP)
- {
- DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
- RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
- return RFAILED;
- }
-
- e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
- e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
- e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
- e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
-
- e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
- e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
- /* Initialize the Ric Indication members */
- RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, \
- e2NodeConfigUpdateAck->protocolIEs.list.size);
- if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
- {
- DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
- break;
- }
-
- for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
- {
- RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
- if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
- {
-
- DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
- break;
- }
- }
-
- arrIdx = 0;
- /* TransactionID */
- e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
- e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
- e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
- e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
-
-
- xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
-
- memset(encBuf, 0, ENC_BUF_MAX_LEN);
- encBufSize = 0;
- encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
- encBuf);
- if(encRetVal.encoded == ENCODE_FAIL)
- {
- DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- return RFAILED;
- }
- else
- {
- DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
- for(int i=0; i< encBufSize; i++)
- {
- DU_LOG("%x",encBuf[i]);
- }
- }
-
-
- /* Sending msg */
- if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
- {
- DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
- return RFAILED;
- }
-
- break;
- }while(true);
-
- FreeE2NodeConfigUpdateAck(e2apMsg);
- return ret;
-}
-
-/*******************************************************************
- *
- * @brief Deallocate the memory allocated for E2 Reset Response
- *
- * @details
- *
- * Function : FreeE2ResetResponse
- *
- * Functionality:
- * - freeing the memory allocated for E2ResetResponse
- *
- * @params[in] E2AP_PDU_t *e2apMsg
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
-{
- uint8_t ieIdx =0;
- ResetResponseE2_t *resetResponse;
-
- if(e2apMsg != NULLP)
- {
- if(e2apMsg->choice.successfulOutcome != NULLP)
- {
- resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
- if(resetResponse->protocolIEs.list.array)
- {
- for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
- {
- if(resetResponse->protocolIEs.list.array[ieIdx])
- {
- RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
- }
- }
- RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
- }
- RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
- }
- RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
- }
-}
-
-/*******************************************************************
- *
- * @brief Buld and send the E2 Reset Response msg
- *
- * @details
- *
- * Function : BuildAndSendE2ResetResponse
- *
- * Functionality:
- * - Buld and send the E2 Reset Response Message
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId)
-{
- uint8_t ieIdx = 0, elementCnt = 0;
- uint8_t ret = RFAILED;
- E2AP_PDU_t *e2apMsg = NULLP;
- ResetResponseE2_t *resetResponse;
- asn_enc_rval_t encRetVal; /* Encoder return value */
-
- DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
- do
- {
- RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
- if(e2apMsg == NULLP)
- {
- DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
- break;
- }
- e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
-
+
RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
if(e2apMsg->choice.successfulOutcome == NULLP)
{
DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
- RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
- return RFAILED;
+ break;
}
e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
{
DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- return RFAILED;
+ break;
}
else
{
if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
{
DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
- return RFAILED;
+ break;
}
ret = ROK;
}while(true);
FreeE2ResetResponse(e2apMsg);
- return ROK;
-}
-
-/*******************************************************************
- *
- * @brief process the E2 Reset Request
- *
- * @details
- *
- * Function : ProcE2ResetReq
- *
- * Functionality: Process E2 Reset Request
- *
- * @return ROK - success
- * RFAILED - failure
- *
- ******************************************************************/
-
-uint8_t ProcE2ResetReq(uint32_t duId, ResetRequestE2_t *resetReq)
-{
- uint8_t ieIdx = 0, duIdx = 0;
- uint8_t transId = 0, cause = 0;
- DuDb *duDb = NULLP;
-
- if(resetReq)
- {
- if(resetReq->protocolIEs.list.array)
- {
- for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
- {
- if(resetReq->protocolIEs.list.array[ieIdx])
- {
- switch(resetReq->protocolIEs.list.array[ieIdx]->id)
- {
- case ProtocolIE_IDE2_id_TransactionID:
- transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
- break;
- case ProtocolIE_IDE2_id_CauseE2:
- DU_LOG("\nDEBUG --> E2AP : Reset reason %d", resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present);
- switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present)
- {
- case CauseE2_PR_NOTHING:
- break;
- case CauseE2_PR_ricRequest:
- cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest;
- break;
- case CauseE2_PR_ricService:
- cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService;
- break;
- case CauseE2_PR_e2Node:
- cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node;
- break;
- case CauseE2_PR_transport:
- cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport;
- break;
- case CauseE2_PR_protocol:
- cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol;
- break;
- case CauseE2_PR_misc:
- cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc;
- break;
- }
- DU_LOG("\nDEBUG --> E2AP : Reset cause %d", cause);
- break;
- }
- }
- }
- }
- }
- BuildAndSendResetResponse(duId, transId);
- return ROK;
+ return ret;
}
/*******************************************************************
int8_t transId =-1;
uint8_t duIdx = 0, elementCnt =0, arrIdx = 0;
uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0;
+ RanFunction *ranFuncDb = NULLP;
RANfunction_ItemIEs_t *ranFuncItemIe =NULL;
RANfunction_Item_t *ranFuncItem =NULL;
RANfunctionID_Item_t *ranFuncIdItem=NULL;
{
ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
- if(duDb->ranFunction[ranFuncItem->ranFunctionID-1].id != ranFuncItem->ranFunctionID)
+ if(fetchRanFuncFromRanFuncId(duDb, ranFuncItem->ranFunctionID) == NULLP)
{
/* Calculating total number of ran fuctions which are not present */
failedRanFuncCount++;
{
delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx];
ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item;
- if(duDb->ranFunction[ranFuncIdItem->ranFunctionID-1].id == ranFuncIdItem->ranFunctionID)
+ ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncIdItem->ranFunctionID);
+ if(ranFuncDb)
{
- memset(&duDb->ranFunction[ranFuncIdItem->ranFunctionID-1], 0, sizeof(RanFunction));
+ memset(ranFuncDb, 0, sizeof(RanFunction));
duDb->numOfRanFunction--;
}
{
uint8_t ieIdx = 0, duIdx = 0, subsIdx = 0;
uint8_t ranFuncId = 0;
- bool ricReqIdDecoded = false;
DuDb *duDb = NULLP;
RanFunction *ranFuncDb = NULLP;
+ RicSubscription *ricSubs = NULLP;
RicRequestId ricReqId;
RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
{
ricReqId.requestorId = ricSubsFailIe->value.choice.RICrequestID.ricRequestorID;
ricReqId.instanceId = ricSubsFailIe->value.choice.RICrequestID.ricInstanceID;
- ricReqIdDecoded = true;
break;
}
case ProtocolIE_IDE2_id_RANfunctionID:
{
ranFuncId = ricSubsFailIe->value.choice.RANfunctionID;
- if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
+ ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
+ if(!ranFuncDb)
+ {
+ DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId);
+ return RFAILED;
+ }
+ else
{
- ranFuncDb = &duDb->ranFunction[ranFuncId-1];
+ /* Remove subscription entry from RAN Function */
+ ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb);
+ if(ricSubs)
+ {
+ memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription));
+ }
}
break;
}
default:
/* No handling required as of now since this is a stub */
break;
-
}
}
}
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Free RIC Subscription Modification Refuse
+ *
+ * @details
+ *
+ * Function : FreeRicSubsModRefuse
+ *
+ * Functionality: Free RIC Subscription Modification Refuse
+ *
+ * @param E2AP Message PDU to be freed
+ * @return void
+ *
+ ******************************************************************/
+void FreeRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t ieIdx =0;
+ RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
- /* Remove subscription entry from RAN Function */
- if(ranFuncDb && ricReqIdDecoded)
+ if(e2apMsg)
+ {
+ if(e2apMsg->choice.unsuccessfulOutcome)
+ {
+ ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
+ if(ricSubsModRefuse->protocolIEs.list.array)
{
- for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++)
+ for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
{
- if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) &&
- (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId))
- {
- memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription));
- break;
- }
+ RIC_FREE(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
}
+ RIC_FREE(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
}
+ RIC_FREE(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
}
+ RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
}
- return ROK;
}
/*******************************************************************
-*
-* @brief Handles received E2AP message and sends back response
-*
-* @details
-*
-* Function : E2APMsgHdlr
-*
-* Functionality:
-* - Decodes received E2AP control message
-* - Prepares response message, encodes and sends to SCTP
-*
-* @params[in]
-* @return ROK - success
-* RFAILED - failure
-*
-* ****************************************************************/
-void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
+ *
+ * @brief Build And Send RIC Subscription Modification Refuse
+ *
+ * @details
+ *
+ * Function : BuildAndSendRicSubsModRefuse
+ *
+ * Functionality: Build And Send RIC Subscription Modification Refuse
+ *
+ * @param DU ID
+ * RIC Request ID of subscription
+ * RAN Function ID
+ * Type of failure
+ * Cause of failure
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t BuildAndSendRicSubsModRefuse(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, CauseE2_PR causeType, \
+ uint8_t cause)
{
- int i;
- char *recvBuf;
- MsgLen copyCnt;
- MsgLen recvBufLen;
- E2AP_PDU_t *e2apMsg;
- asn_dec_rval_t rval; /* Decoder return value */
- E2AP_PDU_t e2apasnmsg ;
-
- DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
- ODU_PRINT_MSG(mBuf, 0,0);
-
- /* Copy mBuf into char array to decode it */
- ODU_GET_MSG_LEN(mBuf, &recvBufLen);
- RIC_ALLOC(recvBuf, (Size)recvBufLen);
+ uint8_t ieIdx = 0, elementCnt = 0;
+ uint8_t ret = RFAILED;
+ E2AP_PDU_t *e2apMsg = NULL;
+ asn_enc_rval_t encRetVal;
+ RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
+ RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
- 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("\nINFO --> E2AP : Building RIC Subscription Modification Refuse\n");
+ while(true)
+ {
+ RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
+ if(e2apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ break;
+ }
+ e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
+ RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
+ if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ break;
+ }
+
+ e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
+ e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
+ e2apMsg->choice.unsuccessfulOutcome->value.present = \
+ UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse;
+ ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
+
+ elementCnt = 3;
+ ricSubsModRefuse->protocolIEs.list.count = elementCnt;
+ ricSubsModRefuse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRefuse_IEs_t *);
+ RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
+ if(!ricSubsModRefuse->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ break;
+ }
+
+ for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
+ {
+ RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
+ if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ break;
+ }
+ }
+
+ /* RIC Request ID */
+ ieIdx = 0;
+ ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
+ ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RICrequestID;
+ ricSubsModRefuseIe->criticality = CriticalityE2_reject;
+ ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RICrequestID;
+ ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
+ ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
+
+ /* RAN Function ID */
+ ieIdx++;
+ ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
+ ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RANfunctionID;
+ ricSubsModRefuseIe->criticality = CriticalityE2_reject;
+ ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RANfunctionID;
+ ricSubsModRefuseIe->value.choice.RANfunctionID = ranFuncId;
+
+ /* Cause */
+ ieIdx++;
+ ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
+ ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_CauseE2;
+ ricSubsModRefuseIe->criticality = CriticalityE2_reject;
+ ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_CauseE2;
+ fillE2FailureCause(&ricSubsModRefuseIe->value.choice.CauseE2, causeType, cause);
+
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
+
+ /* Check encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification refuse (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification refuse\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Refused");
+ break;
+ }
+
+ ret =ROK;
+ break;
+ }
+ FreeRicSubsModRefuse(e2apMsg);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Free memory for RIC Subscription Modification Confirm
+ *
+ * @details
+ *
+ * Function : FreeRicSubsModConfirm
+ *
+ * Functionality: Free memory for RIC subscription modification
+ * confirm
+ *
+ * @param E2AP Message PDU to be freed
+ * @return Void
+ *
+ ******************************************************************/
+void FreeRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t ieIdx = 0, arrIdx=0;
+ RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
+ RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
+ RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
+ RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
+ RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
+ RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
+
+ if(e2apMsg)
+ {
+ if(e2apMsg->choice.successfulOutcome)
+ {
+ ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
+ if(ricSubsModCfm->protocolIEs.list.array)
+ {
+ for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
+ {
+ if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
+ {
+ ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
+ switch(ricSubsModCfmIe->id)
+ {
+ case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
+ {
+ modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
+ if(modCfmList->list.array)
+ {
+ for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
+ {
+ RIC_FREE(modCfmList->list.array[arrIdx], \
+ sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
+ }
+ RIC_FREE(modCfmList->list.array, modCfmList->list.size);
+ }
+ break;
+ }
+
+ case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
+ {
+ modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
+ if(modRefusedList->list.array)
+ {
+ for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
+ {
+ RIC_FREE(modRefusedList->list.array[arrIdx], \
+ sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
+ }
+ RIC_FREE(modRefusedList->list.array, modRefusedList->list.size);
+ }
+ break;
+ }
+
+ case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
+ {
+ rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
+ if(rmvCfmList->list.array)
+ {
+ for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
+ {
+ RIC_FREE(rmvCfmList->list.array[arrIdx], \
+ sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
+ }
+ RIC_FREE(rmvCfmList->list.array, rmvCfmList->list.size);
+ }
+ break;
+ }
+
+ case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
+ {
+ rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
+ if(rmvFailList->list.array)
+ {
+ for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
+ {
+ RIC_ALLOC(rmvFailList->list.array[arrIdx], \
+ sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
+ }
+ RIC_FREE(rmvFailList->list.array, rmvFailList->list.size);
+ }
+ break;
+ }
+
+ default:
+ break;
+
+ }
+ RIC_FREE(ricSubsModCfmIe, sizeof(RICsubscriptionModificationConfirm_IEs_t));
+ }
+ }
+ RIC_FREE(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
+ }
+ RIC_FREE(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
+ }
+ RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fill the list of actions confirmed for modification
+ *
+ * @details
+ *
+ * Function : fillActionModConfirmedList
+ *
+ * Functionality: Fill the list of actions confirmed for modification
+ *
+ * @param List to be filled
+ * Number of actions
+ * Source list of actions
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t fillActionModConfirmedList(RICactions_ConfirmedForModification_List_t *modCfmList, uint8_t numActions, \
+ uint8_t *actionModifiedList)
+{
+ uint8_t arrIdx = 0;
+ RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
+
+ modCfmList->list.count = numActions;
+ modCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForModification_ItemIEs_t *);
+ RIC_ALLOC(modCfmList->list.array, modCfmList->list.size);
+ if(!modCfmList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
+ {
+ RIC_ALLOC(modCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
+ if(!modCfmList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
+ modCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForModification_Item;
+ modCfmListItem->criticality = CriticalityE2_ignore;
+ modCfmListItem->value.present = \
+ RICaction_ConfirmedForModification_ItemIEs__value_PR_RICaction_ConfirmedForModification_Item;
+ modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID = actionModifiedList[arrIdx];
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill the list of actions refused to be modified
+ *
+ * @details
+ *
+ * Function : fillActionModRefusedList
+ *
+ * Functionality: Fill the list of actions refused to be modified
+ *
+ * @param List to be filled
+ * Number of list
+ * Source list of actions refused tobe modified
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t fillActionModRefusedList(RICactions_RefusedToBeModified_List_t *modRefusedList, uint8_t numActions, \
+ ActionFailed *actionModFailedList)
+{
+ uint8_t arrIdx = 0;
+ RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
+
+ modRefusedList->list.count = numActions;
+ modRefusedList->list.size = numActions * sizeof(RICaction_RefusedToBeModified_ItemIEs_t *);
+ RIC_ALLOC(modRefusedList->list.array, modRefusedList->list.size);
+ if(!modRefusedList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
+ {
+ RIC_ALLOC(modRefusedList->list.array[arrIdx], sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
+ if(!modRefusedList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
+ modRefusedListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeModified_Item;
+ modRefusedListItem->criticality = CriticalityE2_ignore;
+ modRefusedListItem->value.present = \
+ RICaction_RefusedToBeModified_ItemIEs__value_PR_RICaction_RefusedToBeModified_Item;
+ modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID = \
+ actionModFailedList[arrIdx].actionId;
+ fillE2FailureCause(&modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.cause, \
+ actionModFailedList[arrIdx].failureType, actionModFailedList[arrIdx].cause);
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill the list of action confirmed for removal
+ *
+ * @details
+ *
+ * Function : fillActionRemovalConfirmedList
+ *
+ * Functionality: Fill the list of action confirmed for removal
+ *
+ * @param List to be filled
+ * Number of actions
+ * Source list of actions removed
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t fillActionRemovalConfirmedList(RICactions_ConfirmedForRemoval_List_t *rmvCfmList, uint8_t numActions, \
+ uint8_t *actionRemovedList)
+{
+ uint8_t arrIdx = 0;
+ RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
+
+ rmvCfmList->list.count = numActions;
+ rmvCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t *);
+ RIC_ALLOC(rmvCfmList->list.array, rmvCfmList->list.size);
+ if(!rmvCfmList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
+ {
+ RIC_ALLOC(rmvCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
+ if(!rmvCfmList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
+ rmvCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForRemoval_Item;
+ rmvCfmListItem->criticality = CriticalityE2_ignore;
+ rmvCfmListItem->value.present = \
+ RICaction_ConfirmedForRemoval_ItemIEs__value_PR_RICaction_ConfirmedForRemoval_Item;
+ rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID = actionRemovedList[arrIdx];
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill the list of actions refused to be removed
+ *
+ * @details
+ *
+ * Function : fillActionRemovalRefusedList
+ *
+ * Functionality: Fill the list of actions refused to be removed
+ *
+ * @param List to be filled
+ * Number of list
+ * Source list of actions refused to be removed
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t fillActionRemovalRefusedList(RICactions_RefusedToBeRemoved_List_t *rmvFailList, \
+ uint8_t numActions, ActionFailed *actionRmvlFailList)
+{
+ uint8_t arrIdx = 0;
+ RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
+
+ rmvFailList->list.count = numActions;
+ rmvFailList->list.size = numActions * sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t *);
+ RIC_ALLOC(rmvFailList->list.array, rmvFailList->list.size);
+ if(!rmvFailList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
+ {
+ RIC_ALLOC(rmvFailList->list.array[arrIdx], sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
+ if(!rmvFailList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
+ rmvFailListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeRemoved_Item;
+ rmvFailListItem->criticality = CriticalityE2_ignore;
+ rmvFailListItem->value.present = \
+ RICaction_RefusedToBeRemoved_ItemIEs__value_PR_RICaction_RefusedToBeRemoved_Item;
+ rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID = actionRmvlFailList[arrIdx].actionId;
+ fillE2FailureCause(&rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.cause, \
+ actionRmvlFailList[arrIdx].failureType, actionRmvlFailList[arrIdx].cause);
+ }
+
+ return ROK;
+
+}
+
+/*******************************************************************
+ *
+ * @brief Build And Send RIC Subscription Modification Confirm
+ *
+ * @details
+ *
+ * Function : BuildAndSendRicSubsModConfirm
+ *
+ * Functionality: Build And Send RIC Subscription Modification Confirm
+ *
+ * @param DU ID
+ * RIC Request ID of subscription
+ * RAN Function ID
+ * Temporary source action list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t BuildAndSendRicSubsModConfirm(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, RicTmpActionList tmpActionList)
+{
+ uint8_t ieIdx = 0, elementCnt = 0;
+ uint8_t ret = RFAILED;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ asn_enc_rval_t encRetVal;
+ RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
+ RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
+
+ DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Confirm\n");
+ while(true)
+ {
+ RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
+ if(e2apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ break;
+ }
+
+ /* Successful Outcome */
+ e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
+ RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
+ if(e2apMsg->choice.successfulOutcome == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ break;
+ }
+
+ e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
+ e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
+ e2apMsg->choice.successfulOutcome->value.present = \
+ SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm;
+ ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
+
+ elementCnt = 2;
+ if(tmpActionList.numActionModified)
+ elementCnt++;
+ if(tmpActionList.numActionModFailed)
+ elementCnt++;
+ if(tmpActionList.numActionRemoved)
+ elementCnt++;
+ if(tmpActionList.numActionRemovalFailed)
+ elementCnt++;
+
+ ricSubsModCfm->protocolIEs.list.count = elementCnt;
+ ricSubsModCfm->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationConfirm_IEs_t *);
+ RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
+ if(!ricSubsModCfm->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ break;
+ }
+
+ for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
+ {
+ RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationConfirm_IEs_t));
+ if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
+ break;
+ }
+ }
+
+ /* RIC Request ID */
+ ieIdx = 0;
+ ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
+ ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICrequestID;
+ ricSubsModCfmIe->criticality = CriticalityE2_reject;
+ ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RICrequestID;
+ ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
+ ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
+
+ /* RAN Function ID */
+ ieIdx++;
+ ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
+ ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RANfunctionID;
+ ricSubsModCfmIe->criticality = CriticalityE2_reject;
+ ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RANfunctionID;
+ ricSubsModCfmIe->value.choice.RANfunctionID = ranFuncId;
+
+ /* RIC Actions List confirmed for modification */
+ if(tmpActionList.numActionModified)
+ {
+ ieIdx++;
+ ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
+ ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List;
+ ricSubsModCfmIe->criticality = CriticalityE2_ignore;
+ ricSubsModCfmIe->value.present = \
+ RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForModification_List;
+ if(fillActionModConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List, \
+ tmpActionList.numActionModified, tmpActionList.actionModifiedList) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Modification List", __func__);
+ break;
+ }
+ }
+
+ /* RIC Actions List refured to be modified */
+ if(tmpActionList.numActionModFailed)
+ {
+ ieIdx++;
+ ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
+ ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List;
+ ricSubsModCfmIe->criticality = CriticalityE2_ignore;
+ ricSubsModCfmIe->value.present = \
+ RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeModified_List;
+ if(fillActionModRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List, \
+ tmpActionList.numActionModFailed, tmpActionList.actionModFailedList) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Refused to be Modified List", __func__);
+ break;
+ }
+ }
+
+ /* RIC Actions List confirmed for removal */
+ if(tmpActionList.numActionRemoved)
+ {
+ ieIdx++;
+ ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
+ ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List;
+ ricSubsModCfmIe->criticality = CriticalityE2_ignore;
+ ricSubsModCfmIe->value.present = \
+ RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForRemoval_List;
+ if(fillActionRemovalConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List, \
+ tmpActionList.numActionRemoved, tmpActionList.actionRemovedList) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Removal List", __func__);
+ break;
+ }
+ }
+
+ /* RIC Actions List Refused to be removed */
+ if(tmpActionList.numActionRemovalFailed)
+ {
+ ieIdx++;
+ ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
+ ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List;
+ ricSubsModCfmIe->criticality = CriticalityE2_ignore;
+ ricSubsModCfmIe->value.present = \
+ RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeRemoved_List;
+ if(fillActionRemovalRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List, \
+ tmpActionList.numActionRemovalFailed, tmpActionList.actionRemovalFailedList) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Failed to be Removed List", __func__);
+ break;
+ }
+ }
+
+ /* Print and encode E2AP Message PDU */
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
+
+ /* Check encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification confirm (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification confirm\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Confirm");
+ break;
+ }
+
+ ret =ROK;
+ break;
+ }
+
+ FreeRicSubsModConfirm(e2apMsg);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Processing of RIC Subscription Modification Required
+ *
+ * @details
+ *
+ * Function : ProcRicSubsModReqd
+ *
+ * Functionality: Processing of RIC Subscription Modification Required
+ * As of now, we do not identify any scenario where this message
+ * shall be sent by DU. Hence, bare minimum handling has been
+ * done here.
+ *
+ * @param DU ID
+ * RIC Subscription Modification Required IEs
+ * @return ROK-success
+ * RFAILED-failure
+ *
+ ******************************************************************/
+uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t *ricSubsModReqd)
+{
+ uint8_t ieIdx = 0, actionIdx = 0, duIdx = 0;
+ DuDb *duDb = NULLP;
+ uint16_t ranFuncId;
+ uint16_t actionId;
+ RicRequestId ricReqId;
+ RanFunction *ranFuncDb = NULLP;
+ RicSubscription *ricSubs = NULLP;
+ ActionInfo *action = NULLP;
+ RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
+ RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
+ RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
+ RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULLP;
+ RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULLP;
+ RicTmpActionList tmpActionList;
+
+ memset(&ricReqId, 0, sizeof(RicRequestId));
+ memset(&tmpActionList, 0, sizeof(RicTmpActionList));
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ return RFAILED;
+ }
+
+ for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
+ {
+ ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
+ switch(ricSubsModReqdIe->id)
+ {
+ case ProtocolIE_IDE2_id_RICrequestID:
+ {
+ ricReqId.requestorId = ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID;
+ ricReqId.instanceId = ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID;
+ break;
+ }
+ case ProtocolIE_IDE2_id_RANfunctionID:
+ {
+ ranFuncId = ricSubsModReqdIe->value.choice.RANfunctionID;
+ ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
+ if(!ranFuncDb)
+ {
+ /* If RIC Subscription not found, send RIC Subscription modification refuse to DU */
+ DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RIC Subscription not found");
+ BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
+ CauseE2RICrequest_ran_function_id_invalid);
+ return RFAILED;
+ }
+
+ ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb);
+ if(!ricSubs)
+ {
+ /* If RAN Function not found, send RIC Subscription modification refuse to DU */
+ DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RAN Function ID [%d] not found",ranFuncId);
+ BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, \
+ CauseE2_PR_ricRequest, CauseE2RICrequest_request_id_unknown);
+ return RFAILED;
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
+ {
+ actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
+ for(actionIdx = 0; actionIdx < actionToBeModList->list.count; actionIdx++)
+ {
+ actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[actionIdx];
+ actionId = actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID;
+ action = fetchActionInfoFromActionId(actionId, ricSubs);
+ if(action)
+ {
+ /* No modification required as of now, hence directly adding to the list */
+ tmpActionList.actionModifiedList[tmpActionList.numActionModified++] = actionId;
+ }
+ else
+ {
+ tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].actionId = actionId;
+ tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].failureType = \
+ CauseE2_PR_ricRequest;
+ tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].cause = \
+ CauseE2RICrequest_action_not_supported;
+ tmpActionList.numActionModFailed++;
+ }
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
+ {
+ actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
+ for(actionIdx = 0; actionIdx < actionToBeRmvList->list.count; actionIdx++)
+ {
+ actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[actionIdx];
+ actionId = actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID;
+ action = fetchActionInfoFromActionId(actionId, ricSubs);
+ if(action)
+ {
+ tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId;
+ memset(action, 0, sizeof(ActionInfo));
+ action->actionId = -1;
+ ricSubs->numOfActions--;
+ }
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ /* If none of the action modification/removal is supported,
+ * send RIC Subscription Modification Refuse
+ * Else
+ * send RIC Subscription Modification Confirm
+ */
+ if(tmpActionList.numActionModified || tmpActionList.numActionRemoved)
+ {
+ BuildAndSendRicSubsModConfirm(duId, ricReqId, ranFuncId, tmpActionList);
+ }
+ else
+ {
+ BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
+ CauseE2RICrequest_action_not_supported);
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Free the ErrorIndication Message
+ *
+ * @details
+ *
+ * Function : FreeRicIndication
+ *
+ * Functionality: Free the ErrorIndication Message
+ *
+ * @return void
+ *
+ *
+ ******************************************************************/
+void FreeErrorIndication(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t arrIdx = 0;
+ ErrorIndicationE2_t *errorIndicationMsg= NULLP;
+
+ if(e2apMsg != NULLP)
+ {
+ if(e2apMsg->choice.initiatingMessage != NULLP)
+ {
+ errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
+ if(errorIndicationMsg!= NULLP)
+ {
+ if(errorIndicationMsg->protocolIEs.list.array != NULLP)
+ {
+ for(arrIdx=0; arrIdx<errorIndicationMsg->protocolIEs.list.count; arrIdx++)
+ {
+ RIC_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t));
+ }
+ RIC_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size);
+ }
+ }
+ RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ }
+ RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
+ }
+}
+
+
+/*******************************************************************
+ *
+ * @brief Builds and Send the ErrorIndication Message
+ *
+ * @details
+ *
+ * Function : BuildAndSendErrorIndication
+ *
+ * Functionality:Fills the ErrorIndication Message
+ *
+ * @params[in]
+ * DU id
+ * Trans id
+ * Ric req id
+ * Ran function id
+ * Reason of failure
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t BuildAndSendErrorIndication(uint32_t duId, int8_t transId, RicRequestId requestId, uint16_t ranFuncId, uint8_t reason)
+{
+ uint8_t elementCnt =0, arrIdx=0, ret = RFAILED;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ ErrorIndicationE2_t *errorIndicationMsg=NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+
+ while(true)
+ {
+ DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
+
+ RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
+ if(e2apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
+ break;
+ }
+
+ e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
+ RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ if(e2apMsg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
+ break;
+ }
+ e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
+ e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
+ e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2;
+
+ errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
+
+ /* Element count is 2 for TransactionID/RICrequestID and Cause.
+ * If the RAN function id is present, the count will be increased.*/
+ elementCnt = 2;
+ if(ranFuncId>0)
+ elementCnt++;
+
+ errorIndicationMsg->protocolIEs.list.count = elementCnt;
+ errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*);
+
+ /* Initialize the E2Setup members */
+ RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
+ if(errorIndicationMsg->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
+ break;
+ }
+ for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
+ {
+ RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
+ if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for array Idx %d in %s at line %d",arrIdx,__func__, __LINE__);
+ break;
+ }
+ }
+ if(arrIdx < elementCnt)
+ break;
+
+ arrIdx = 0;
+
+ if(transId >=0 && transId<=255)
+ {
+ /* TransactionID */
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
+ }
+ else
+ {
+ /* RICrequestID */
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
+ }
+
+ if(ranFuncId>0)
+ {
+ /* RAN Function ID */
+ arrIdx++;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId;
+ }
+
+ /* Cause */
+ arrIdx++;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
+ errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
+ fillE2FailureCause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, CauseE2_PR_misc, reason);
+
+
+ /* Prints the Msg formed */
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
+ encBuf);
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
+#ifdef DEBUG_ASN_PRINT
+ for(int i=0; i< encBufSize; i++)
+ {
+ printf("%x",encBuf[i]);
+ }
+#endif
+ }
+
+ if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
+ {
+ DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
+
+ }
+ ret = ROK;
+ break;
+ }
+ FreeErrorIndication(e2apMsg);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Deallocate the memory allocated for ResetRequest msg
+ *
+ * @details
+ *
+ * Function : FreeResetRequest
+ *
+ * Functionality:
+ * - freeing the memory allocated for ResetRequest
+ *
+ * @params[in] E2AP_PDU_t *e2apMsg
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void FreeResetRequest(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t ieIdx =0;
+ ResetRequestE2_t *resetReq = NULLP;
+
+ if(e2apMsg != NULLP)
+ {
+ if(e2apMsg->choice.initiatingMessage != NULLP)
+ {
+ resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
+ if(resetReq->protocolIEs.list.array)
+ {
+ for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
+ {
+ RIC_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
+ }
+ RIC_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
+ }
+ RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ }
+ RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Build and send the reset request msg
+ *
+ * @details
+ *
+ * Function : BuildAndSendResetRequest
+ *
+ * Functionality:
+ * - Buld and send the reset request msg to E2 node
+ *
+ * @params[in]
+ * DU database
+ * Type of failure
+ * Cause of failure
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildAndSendResetRequest(DuDb *duDb, CauseE2_PR causePresent, uint8_t reason)
+{
+ uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
+ uint8_t ret = RFAILED;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ ResetRequestE2_t *resetReq = NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+
+ DU_LOG("\nINFO --> E2AP : Building Reset Request\n");
+
+ do
+ {
+ RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
+ if(e2apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for E2AP-PDU failed");
+ break;
+ }
+
+ e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
+ RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ if(e2apMsg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for initiatingMessage");
+ break;
+ }
+
+ e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
+ e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
+ e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
+ resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
+
+ elementCnt = 2;
+ resetReq->protocolIEs.list.count = elementCnt;
+ resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
+
+ RIC_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
+ if(!resetReq->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
+ Reset Request IE array");
+ break;
+ }
+
+ for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
+ {
+ RIC_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
+ if(!resetReq->protocolIEs.list.array[ieIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
+ Reset Request IE array element");
+ break;
+ }
+ }
+
+ /* In case of failure */
+ if(ieIdx < elementCnt)
+ break;
+
+ ieIdx = 0;
+ resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
+ resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
+ resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
+ transId = assignTransactionId(duDb);
+ resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
+
+ ieIdx++;
+ resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
+ resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
+ resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
+ fillE2FailureCause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
+
+ /* Prints the Msg formed */
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
+
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
+ encBuf);
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
+#ifdef DEBUG_ASN_PRINT
+ for(int i=0; i< encBufSize; i++)
+ {
+ printf("%x",encBuf[i]);
+ }
+#endif
+ }
+ if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Sending reset request failed");
+ break;
+ }
+
+
+ ret = ROK;
+ break;
+ }while(true);
+
+ /* Free all memory */
+ FreeResetRequest(e2apMsg);
+ return ret;
+}
+
+
+/*******************************************************************
+ *
+ * @brief delete ric subscription information
+ *
+ * @details
+ *
+ * Function : deleteRicSubscription
+ *
+ * Functionality: Process ric subscription information
+ *
+ * @params[in]
+ * Pointer to DU database
+ * @return void
+
+ *
+ ******************************************************************/
+void deleteRicSubscription(DuDb **duDb)
+{
+ RanFunction *ranFuncDb = NULLP;
+ uint16_t ranFuncIdx=0;
+
+ for(ranFuncIdx =0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
+ {
+ ranFuncDb = &(*duDb)->ranFunction[ranFuncIdx];
+ if(ranFuncDb->id > 0)
+ {
+ memset(&ranFuncDb->subscriptionList, 0,MAX_RIC_REQUEST*sizeof(RicSubscription));
+ ranFuncDb->numOfSubscription =0;
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief process the E2 Reset Response
+ *
+ * @details
+ *
+ * Function : ProcResetResponse
+ *
+ * Functionality: Process E2 Reset Response
+ *
+ * @params[in]
+ * du Id
+ * Pointer to reset response
+ * @return void
+ *
+ ******************************************************************/
+
+void ProcResetResponse(uint32_t duId, ResetResponseE2_t *resetRsp)
+{
+ uint8_t ieIdx = 0, duIdx =0;
+ DuDb *duDb = NULLP;
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ return;
+ }
+
+ if(!resetRsp)
+ {
+ DU_LOG("\nERROR --> E2AP : resetRsp pointer is null");
+ return;
+ }
+
+ if(!resetRsp->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : resetRsp array pointer is null");
+ return;
+ }
+
+ for(ieIdx=0; ieIdx < resetRsp->protocolIEs.list.count; ieIdx++)
+ {
+ if(resetRsp->protocolIEs.list.array[ieIdx])
+ {
+ switch(resetRsp->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_TransactionID:
+ {
+ deleteRicSubscription(&duDb);
+ break;
+ }
+ case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
+ {
+ break;
+ }
+ }
+ }
+ }
+}
+
+
+/*******************************************************************
+ *
+ * @brief process the E2 Reset Request
+ *
+ * @details
+ *
+ * Function : ProcResetRequest
+ *
+ * Functionality: Process E2 Reset Request
+ *
+ * @params[in]
+ * du Id
+ * Pointer to reset response
+ * @return void
+ *
+ ******************************************************************/
+
+void ProcResetRequest(uint32_t duId, ResetRequestE2_t *resetReq)
+{
+ uint8_t ieIdx = 0, duIdx =0, transId=0;
+ DuDb *duDb = NULLP;
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ return;
+ }
+
+ if(!resetReq)
+ {
+ DU_LOG("\nERROR --> E2AP : resetReq pointer is null");
+ return;
+ }
+
+ if(!resetReq->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : resetReq array pointer is null");
+ return;
+ }
+
+ for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
+ {
+ if(resetReq->protocolIEs.list.array[ieIdx])
+ {
+ switch(resetReq->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_TransactionID:
+ {
+ transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
+ break;
+ }
+ case ProtocolIE_IDE2_id_CauseE2:
+ {
+ deleteRicSubscription(&duDb);
+ break;
+ }
+ }
+ }
+ }
+
+ if(BuildAndSendResetResponse(duId, transId) !=ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
+ }
+}
+/*******************************************************************
+*
+* @brief Handles received E2AP message and sends back response
+*
+* @details
+*
+* Function : E2APMsgHdlr
+*
+* Functionality:
+* - Decodes received E2AP control message
+* - Prepares response message, encodes and sends to SCTP
+*
+* @params[in]
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
+{
+ int i;
+ char *recvBuf;
+ MsgLen copyCnt;
+ MsgLen recvBufLen;
+ E2AP_PDU_t *e2apMsg;
+ asn_dec_rval_t rval; /* Decoder return value */
+ E2AP_PDU_t e2apasnmsg ;
+
+ DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
+ ODU_PRINT_MSG(mBuf, 0,0);
+
+ /* Copy mBuf into char array to decode it */
+ ODU_GET_MSG_LEN(mBuf, &recvBufLen);
+ RIC_ALLOC(recvBuf, (Size)recvBufLen);
+
+ if(recvBuf == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed");
+ return;
+ }
+ if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
{
DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
return;
case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
{
DU_LOG("\nINFO --> E2AP : E2 node config update received");
- BuildAndSendE2NodeConfigUpdateAck(*duId);
+ ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate);
break;
}
case InitiatingMessageE2__value_PR_ResetRequestE2:
{
DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
- ProcE2ResetReq(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
+ ProcResetRequest(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
break;
}
case InitiatingMessageE2__value_PR_RICindication:
{
- DU_LOG("\nINFO --> E2AP : RIC Indication Acknowledged");
+ DU_LOG("\nINFO --> E2AP : RIC Indication received");
break;
}
case InitiatingMessageE2__value_PR_RICserviceUpdate:
ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate);
break;
}
+ case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired:
+ {
+ DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Required");
+ ProcRicSubsModReqd(*duId, \
+ &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired);
+ break;
+ }
+ case InitiatingMessageE2__value_PR_ErrorIndicationE2:
+ {
+ DU_LOG("\nINFO --> E2AP : Error indication received");
+ break;
+ }
default:
{
DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \
{
switch(e2apMsg->choice.successfulOutcome->value.present)
{
+ case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
+ {
+ DU_LOG("\nINFO --> E2AP : Reset response received");
+ ProcResetResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2);
+ break;
+ }
case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
{
ProcRicSubscriptionResponse(*duId, \
Code Review / o-du / l2.git / blobdiff