+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+ connectionRemove = (E2connectionUpdateRemove_ItemIEs_t*)connectionToBeRemoveList->list.array[arrIdx];
+ connectionRemove->id = ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item;
+ connectionRemove->criticality= CriticalityE2_ignore;
+ connectionRemove->value.present = E2connectionUpdateRemove_ItemIEs__value_PR_E2connectionUpdateRemove_Item;
+ if(fillE2connectionUpdateItem((PTR)&connectionRemove->value.choice.E2connectionUpdateRemove_Item, ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to fill E2 connection update item");
+ return RFAILED;
+ }
+
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Deallocate the memory allocated for E2ConnectionUpdate msg
+ *
+ * @details
+ *
+ * Function : FreeE2ConnectionUpdate
+ *
+ * Functionality:
+ * - freeing the memory allocated for E2ConnectionUpdate
+ *
+ * @params[in] E2AP_PDU_t *e2apMsg
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void FreeE2ConnectionUpdate(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t ieIdx =0, arrIdx=0;
+ E2connectionUpdate_t *connectionUpdate = NULLP;
+ E2connectionUpdate_List_t *connectionToBeModifyList = NULLP;
+ E2connectionUpdateRemove_List_t *connectionToBeRemoveList = NULLP;
+
+ if(e2apMsg != NULLP)
+ {
+ if(e2apMsg->choice.initiatingMessage != NULLP)
+ {
+ connectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
+ if(connectionUpdate->protocolIEs.list.array)
+ {
+ for(ieIdx = 0; ieIdx < connectionUpdate->protocolIEs.list.count; ieIdx++)
+ {
+ if(connectionUpdate->protocolIEs.list.array[ieIdx])
+ {
+ switch(connectionUpdate->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_TransactionID:
+ break;
+
+ case ProtocolIE_IDE2_id_E2connectionUpdateModify:
+ {
+ connectionToBeModifyList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
+ if(connectionToBeModifyList->list.array)
+ {
+ for(arrIdx = 0; arrIdx < connectionToBeModifyList->list.count; arrIdx++)
+ {
+ RIC_FREE(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
+ }
+ RIC_FREE(connectionToBeModifyList->list.array, connectionToBeModifyList->list.size);
+ }
+ break;
+ }
+
+ case ProtocolIE_IDE2_id_E2connectionUpdateRemove:
+ {
+ connectionToBeRemoveList = &connectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List;
+ if(connectionToBeRemoveList->list.array)
+ {
+ for(arrIdx = 0; arrIdx < connectionToBeRemoveList->list.count; arrIdx++)
+ {
+ RIC_FREE(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
+ }
+ RIC_FREE(connectionToBeRemoveList->list.array, connectionToBeRemoveList->list.size);
+ }
+ break;
+ }
+ }
+ RIC_FREE(connectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
+ }
+ }
+ RIC_FREE(connectionUpdate->protocolIEs.list.array, connectionUpdate->protocolIEs.list.size);
+ }
+ RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ }
+ RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Buld and send the E2 Connection Update msg
+ *
+ * @details
+ *
+ * Function : BuildAndSendE2ConnectionUpdate
+ *
+ * Functionality:
+ * - Buld and send the E2 Connection Update Message
+ * @params[in]
+ * Du Id
+ * E2 connection to be modify or delete
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t BuildAndSendE2ConnectionUpdate(uint32_t duId, E2Connection connectionInfo)
+{
+ uint8_t ieIdx = 0, elementCnt = 0;
+ uint8_t ret = RFAILED, duIdx =0;
+ DuDb *duDb = NULLP;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ E2connectionUpdate_t *e2ConnectionUpdate=NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+
+ DU_LOG("\nINFO --> E2AP : Building E2 Connection Update Message\n");
+ do
+ {
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ return RFAILED;
+ }
+
+ RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
+ if(e2apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation 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 failed in %s at line %d", __func__, __LINE__);
+ break;
+ }
+
+ e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2connectionUpdate;
+ e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
+ e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2connectionUpdate;
+ e2ConnectionUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2connectionUpdate;
+
+ elementCnt = 1;
+ if(connectionInfo == MODIFY_CONNECTION)
+ elementCnt++;
+ if(connectionInfo == REMOVE_CONNECTION)
+ elementCnt++;
+
+ e2ConnectionUpdate->protocolIEs.list.count = elementCnt;
+ e2ConnectionUpdate->protocolIEs.list.size = elementCnt * sizeof(E2connectionUpdate_IEs_t*);
+ RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array, e2ConnectionUpdate->protocolIEs.list.size);
+ if(!e2ConnectionUpdate->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ break;
+ }
+
+ for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
+ {
+ RIC_ALLOC(e2ConnectionUpdate->protocolIEs.list.array[ieIdx], sizeof(E2connectionUpdate_IEs_t));
+ if(!e2ConnectionUpdate->protocolIEs.list.array[ieIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ break;
+ }
+ }
+ if(ieIdx < elementCnt)
+ break;
+
+ ieIdx = 0;
+ e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
+ e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
+ e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_TransactionID;
+ e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = assignTransactionId(duDb);
+
+ if(connectionInfo == MODIFY_CONNECTION)
+ {
+ ieIdx++;
+ e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionUpdateModify;
+ e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
+ e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdate_List;
+ if(BuildE2ConnectionModifyList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
+ break;
+ }
+ }
+
+ if(connectionInfo == REMOVE_CONNECTION)
+ {
+ ieIdx++;
+ e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_E2connectionUpdateRemove;
+ e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
+ e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.present = E2connectionUpdate_IEs__value_PR_E2connectionUpdateRemove_List;
+ if(BuildE2ConnectionRemoveList(&e2ConnectionUpdate->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdateRemove_List) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to build the connection update modify list");
+ break;
+ }
+ }
+
+ 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 connection update structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Connection Update \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 Connection Update");
+ break;
+ }
+
+ ret = ROK;
+ break;
+ }while(true);
+
+ FreeE2ConnectionUpdate(e2apMsg);
+ return ret;
+}
+
+/******************************************************************
+ *
+ * @brief Processes the E2 connection update failure msg
+ *
+ * @details
+ *
+ * Function : procE2connectionUpdateFailure
+ *
+ * Functionality: Processes the E2 connection update failure msg
+ *
+ * @params[in]
+ * E2 connection update failure information
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void ProcE2connectionUpdateFailure(E2connectionUpdateFailure_t *updateFailure)
+{
+ uint8_t ieIdx = 0;
+ uint16_t transId=0;
+ CauseE2_t *cause = NULLP;
+
+ if(!updateFailure)
+ {
+ DU_LOG("\nERROR --> E2AP : updateFailure pointer is null");
+ return;
+ }
+
+ if(!updateFailure->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : updateFailure array pointer is null");
+ return;
+ }
+
+ for(ieIdx=0; ieIdx < updateFailure->protocolIEs.list.count; ieIdx++)
+ {
+ if(updateFailure->protocolIEs.list.array[ieIdx])
+ {
+ switch(updateFailure->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_TransactionID:
+ {
+ transId = updateFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
+ DU_LOG("\nERROR --> E2AP : Received transID %d", transId);
+ break;
+ }
+ case ProtocolIE_IDE2_id_CauseE2:
+ {
+ cause = &updateFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
+ printE2ErrorCause(cause);
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", updateFailure->protocolIEs.list.array[ieIdx]->id);
+ break;
+ }
+ }
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief process the E2 Connection update ack
+ *
+ * @details
+ *
+ * Function : ProcE2ConnectionUpdateAck
+ *
+ * Functionality: Process E2 Connection update ack
+ *
+ * @params[in]
+ * du Id
+ * Pointer to Connection update ack
+ * @return void
+ *
+ ******************************************************************/
+
+void ProcE2ConnectionUpdateAck(uint32_t duId, E2connectionUpdateAcknowledge_t *connectionUpdateAck)
+{
+ uint16_t transId =0;
+ uint32_t ipAddress=0;
+ DuDb *duDb = NULLP;
+ uint8_t ieIdx = 0, duIdx =0, arrIdx=0;
+ E2connectionUpdate_Item_t *connectionSetupItem=NULLP;
+ E2connectionUpdate_ItemIEs_t *connectionSetupItemIe=NULLP;
+ E2connectionUpdate_List_t *connectionSetupList=NULLP;
+ E2connectionSetupFailed_Item_t *setupFailedItem =NULLP;
+ E2connectionSetupFailed_List_t *setupFailedList=NULLP;
+ E2connectionSetupFailed_ItemIEs_t *setupFailedItemIe =NULLP;
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ return;
+ }
+
+ if(!connectionUpdateAck)
+ {
+ DU_LOG("\nERROR --> E2AP : connectionUpdateAck pointer is null");
+ return;
+ }
+
+ if(!connectionUpdateAck->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : connectionUpdateAck array pointer is null");
+ return;
+ }
+
+ for(ieIdx=0; ieIdx < connectionUpdateAck->protocolIEs.list.count; ieIdx++)
+ {
+ if(connectionUpdateAck->protocolIEs.list.array[ieIdx])
+ {
+ switch(connectionUpdateAck->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_TransactionID:
+ {
+ transId = connectionUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
+ if(transId>255)
+ {
+ DU_LOG("\nERROR --> E2AP : Received invalid trans id %d ",transId);
+ return;
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_E2connectionSetup:
+ {
+ connectionSetupList=&connectionUpdateAck->protocolIEs.list.array[ieIdx]->value.choice.E2connectionUpdate_List;
+ if(connectionSetupList->list.array)
+ {
+ for(arrIdx = 0; arrIdx< connectionSetupList->list.count; arrIdx++)
+ {
+ connectionSetupItemIe = (E2connectionUpdate_ItemIEs_t*)connectionSetupList->list.array[arrIdx];
+ connectionSetupItem = &connectionSetupItemIe->value.choice.E2connectionUpdate_Item;
+ bitStringToInt(&connectionSetupItem->tnlInformation.tnlAddress, &ipAddress);
+ if(ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr == ipAddress)
+ {
+ ricCb.ricCfgParams.sctpParams.usage = connectionSetupItem->tnlUsage;
+ }
+ }
+ }
+ break;
+ }
+
+ case ProtocolIE_IDE2_id_E2connectionSetupFailed:
+ {
+ setupFailedList=&connectionUpdateAck->protocolIEs.list.array[ieIdx]->value.choice.E2connectionSetupFailed_List;
+ if(setupFailedList->list.array)
+ {
+ for(arrIdx = 0; arrIdx< setupFailedList->list.count; arrIdx++)
+ {
+ setupFailedItemIe = (E2connectionSetupFailed_ItemIEs_t*)setupFailedList->list.array[arrIdx];
+ setupFailedItem = &setupFailedItemIe->value.choice.E2connectionSetupFailed_Item;
+ printE2ErrorCause(&setupFailedItem->cause);
+ }
+ }
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", connectionUpdateAck->protocolIEs.list.array[ieIdx]->id);
+ break;
+ }
+ }
+ }
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Processes the Ric Subs delete failure msg
+ *
+ * @details
+ *
+ * Function : procRicSubsDeleteFailure
+ *
+ * Functionality: Processes the Ric Subs delete failure msg
+ *
+ * @params[in]
+ * Ric Subs delete failure information
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void ProcRicSubsDeleteFailure(RICsubscriptionDeleteFailure_t *ricSubsDeleteFail)
+{
+ uint8_t ieIdx = 0;
+ uint16_t ranFuncId=0;
+ CauseE2_t *cause = NULLP;
+ RICrequestID_t ricRequestID;
+
+ if(!ricSubsDeleteFail)
+ {
+ DU_LOG("\nERROR --> E2AP : ricSubsDeleteFail pointer is null");
+ return;
+ }
+
+ if(!ricSubsDeleteFail->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : ricSubsDeleteFail array pointer is null");
+ return;
+ }
+
+ for(ieIdx=0; ieIdx < ricSubsDeleteFail->protocolIEs.list.count; ieIdx++)
+ {
+ if(ricSubsDeleteFail->protocolIEs.list.array[ieIdx])
+ {
+ switch(ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_RICrequestID:
+ {
+ memcpy(&ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t));
+ DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
+ break;
+ }
+ case ProtocolIE_IDE2_id_RANfunctionID:
+ {
+ ranFuncId = ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
+ DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId);
+ break;
+ }
+ case ProtocolIE_IDE2_id_CauseE2:
+ {
+ cause = &ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
+ printE2ErrorCause(cause);
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsDeleteFail->protocolIEs.list.array[ieIdx]->id);
+ break;
+ }
+ }
+ }
+ }
+}
+
+
+/******************************************************************
+ *
+ * @brief Processes the Ric Subs delete rsp msg
+ *
+ * @details
+ *
+ * Function : ProcRicSubsDeleteRsp
+ *
+ * Functionality: Processes the Ric Subs delete rsp msg
+ *
+ * @params[in]
+ * Ric Subs delete rsp information
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void ProcRicSubsDeleteRsp(uint32_t duId, RICsubscriptionDeleteResponse_t *ricSubsDeleteRsp)
+{
+ uint8_t ieIdx = 0;
+ uint8_t duIdx= 0;
+ uint16_t ranFuncId=0;
+ RanFunction *ranFuncDb = NULLP;
+ RicRequestId ricReqId;
+ DuDb *duDb = NULLP;
+ RicSubscription *ricSubs = NULLP;
+ CmLList *ricSubsNode = NULLP;
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ return;
+ }
+
+ if(!ricSubsDeleteRsp)
+ {
+ DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp pointer is null");
+ return;
+ }
+
+ if(!ricSubsDeleteRsp->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : ricSubsDeleteRsp array pointer is null");
+ return;
+ }
+ for(ieIdx=0; ieIdx < ricSubsDeleteRsp->protocolIEs.list.count; ieIdx++)
+ {
+ if(ricSubsDeleteRsp->protocolIEs.list.array[ieIdx])
+ {
+ switch(ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_RICrequestID:
+ {
+ ricReqId.requestorId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricRequestorID;
+ ricReqId.instanceId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricInstanceID;
+ break;
+ }
+ case ProtocolIE_IDE2_id_RANfunctionID:
+ {
+ ranFuncId = ricSubsDeleteRsp->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
+ ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
+ if(!ranFuncDb)
+ {
+ DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
+ return;
+ }
+
+ ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
+ if(ricSubs)
+ {
+ deleteRicSubscriptionNode(ricSubsNode);
+ DU_LOG("\nINFO --> E2AP : Ric subscription node deleted successfully");
+ }
+ else
+ {
+ DU_LOG("\nERROR --> E2AP : Ric subscription node is not present ");
+ return;
+ }
+ break;
+ }
+ }
+ }
+ }
+}
+
+
+ /******************************************************************
+ *
+ * @brief Processes the Ric Subs modification failure msg
+ *
+ * @details
+ *
+ * Function : procRicSubsModificationFailure
+ *
+ * Functionality: Processes the Ric Subs modification failure msg
+ *
+ * @params[in]
+ * Ric Subs modification failure information
+ *
+ * @return void
+ *
+ * ****************************************************************/
+ void ProcRicSubsModificationFailure(RICsubscriptionModificationFailure_t *ricSubsModificationFail)
+ {
+ uint8_t ieIdx = 0;
+ uint16_t ranFuncId=0;
+ CauseE2_t *cause = NULLP;
+ RICrequestID_t ricRequestID;
+
+ DU_LOG("\nINFO --> E2AP : Ric subscription modification failure received");
+
+ if(!ricSubsModificationFail)
+ {
+ DU_LOG("\nERROR --> E2AP : ricSubsModificationFail pointer is null");
+ return;
+ }
+
+ if(!ricSubsModificationFail->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : ricSubsModificationFail array pointer is null");
+ return;
+ }
+
+ for(ieIdx=0; ieIdx < ricSubsModificationFail->protocolIEs.list.count; ieIdx++)
+ {
+ if(ricSubsModificationFail->protocolIEs.list.array[ieIdx])
+ {
+ switch(ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_RICrequestID:
+ {
+ memcpy(&ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID, &ricRequestID, sizeof(RICrequestID_t));
+ DU_LOG("\nERROR --> E2AP : Received RicReqId %ld and InstanceId %ld", ricRequestID.ricRequestorID, ricRequestID.ricInstanceID);
+ break;
+ }
+ case ProtocolIE_IDE2_id_RANfunctionID:
+ {
+ ranFuncId = ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
+ DU_LOG("\nERROR --> E2AP : Received ranfuncId %d", ranFuncId);
+ break;
+ }
+ case ProtocolIE_IDE2_id_CauseE2:
+ {
+ cause = &ricSubsModificationFail->protocolIEs.list.array[ieIdx]->value.choice.CauseE2;
+ printE2ErrorCause(cause);
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationFail->protocolIEs.list.array[ieIdx]->id);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+/*******************************************************************
+ *
+ * @brief Free RIC Subscription action to be added list
+ *
+ * @details
+ *
+ * Function : FreeRicSubsActionToBeAdded
+ *
+ * Functionality: Free the RIC Subscription action to be added list
+ *
+ * @params[in] RICactions_ToBeAddedForModification_List_t *subsDetails
+ * @return void
+ *
+ * ****************************************************************/
+void FreeRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *subsDetails)
+{
+ uint8_t elementIdx = 0;
+ RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe=NULLP;
+
+ if(subsDetails->list.array)
+ {
+ for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
+ {
+ if(subsDetails->list.array[elementIdx])
+ {
+ addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)subsDetails->list.array[elementIdx];
+ RIC_FREE(addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.buf, \
+ addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition.size);
+ RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t));
+ }
+ }
+ RIC_FREE(subsDetails->list.array, subsDetails->list.size);
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Free RIC Subscription action to be removed list
+ *
+ * @details
+ *
+ * Function : FreeRicSubsActionToBeRemoved
+ *
+ * Functionality: Free the RIC Subscription action to be removed list
+ *
+ * @params[in] RICactions_ToBeRemovedForModification_List_t *subsDetails
+ * @return void
+ *
+ * ****************************************************************/
+void FreeRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *subsDetails)
+{
+ uint8_t elementIdx = 0;
+
+ if(subsDetails->list.array)
+ {
+ for(elementIdx = 0; elementIdx < subsDetails->list.count; elementIdx++)
+ {
+ RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t));
+ }
+ RIC_FREE(subsDetails->list.array, subsDetails->list.size);
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Free RIC Subscription action to be modify
+ *
+ * @details
+ *
+ * Function : FreeRicSubsActionToBeModified
+ *
+ * Functionality: Free the RIC Subscription action to be modify
+ *
+ * @params[in] RICactions_ToBeModifiedForModification_List_t List
+ * @return void
+ *
+ * ****************************************************************/
+void FreeRicSubsActionToBeModified(RICactions_ToBeModifiedForModification_List_t *subsDetails)
+{
+ uint8_t elementIdx = 0;
+ RICaction_ToBeModifiedForModification_ItemIEs_t *actionItem = NULLP;
+
+ if(subsDetails->list.array)
+ {
+ 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)
+ {
+ RIC_FREE(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->buf, \
+ actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition->size);
+ RIC_FREE(actionItem->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
+ }
+ RIC_FREE(subsDetails->list.array[elementIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t))
+ }
+ }
+ RIC_FREE(subsDetails->list.array, subsDetails->list.size);
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Free RIC Subscription modification Request
+ *
+ * @details
+ *
+ * Function :FreeRicSubscriptionModReq
+ *
+ * Functionality : Free RIC Subscription modification Request
+ *
+ * @params[in] E2AP_PDU
+ * @return void
+ *
+ ******************************************************************/
+void FreeRicSubscriptionModReq(E2AP_PDU_t *e2apRicMsg)
+{
+ uint8_t idx = 0;
+ RICsubscriptionModificationRequest_t *ricSubscriptionModReq =NULLP;
+ RICsubscriptionModificationRequest_IEs_t *ricSubscriptionModReqIe=NULLP;
+
+ if(e2apRicMsg)
+ {
+ if(e2apRicMsg->choice.initiatingMessage)
+ {
+ ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
+ if(ricSubscriptionModReq->protocolIEs.list.array)
+ {
+ for(idx=0; idx < ricSubscriptionModReq->protocolIEs.list.count; idx++)
+ {
+ if(ricSubscriptionModReq->protocolIEs.list.array[idx])
+ {
+ ricSubscriptionModReqIe = ricSubscriptionModReq->protocolIEs.list.array[idx];
+ switch(ricSubscriptionModReq->protocolIEs.list.array[idx]->id)
+ {
+ case ProtocolIE_IDE2_id_RICrequestID:
+ break;
+ case ProtocolIE_IDE2_id_RANfunctionID:
+ break;
+ case ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List:
+ {
+ FreeRicSubsActionToBeRemoved(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeRemovedForModification_List));
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List:
+ {
+ FreeRicSubsActionToBeModified(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeModifiedForModification_List));
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List:
+ {
+ FreeRicSubsActionToBeAdded(&(ricSubscriptionModReqIe->value.choice.RICactions_ToBeAddedForModification_List));
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubscriptionModReq->protocolIEs.list.array[idx]->id);
+ break;
+ }
+
+ }
+
+ RIC_FREE(ricSubscriptionModReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionModificationRequest_IEs_t));
+ }
+ }
+ RIC_FREE(ricSubscriptionModReq->protocolIEs.list.array, ricSubscriptionModReq->protocolIEs.list.size);
+ }
+ RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ }
+ RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
+ }
+}
+
+/*******************************************************************
+*
+* @brief Build Ric subscription action to be modify list
+*
+* @details
+*
+* Function : BuildRicSubsActionToBeModify
+*
+* Functionality: Build Ric subscription action to be modify list
+*
+* @params[in]
+* RICactions_ToBeModifiedForModification_List_t to be filled
+* Num of action to be modify
+* List of action to be modify
+*
+* @return ROK - success
+* RFAILED - failure
+*
+******************************************************************/
+
+uint8_t BuildRicSubsActionToBeModify(RICactions_ToBeModifiedForModification_List_t *modifyActionList, uint8_t numOfActionToBeModify, ActionInfo *actionToBeModify)
+{
+ uint8_t arrIdx=0;
+ RICaction_ToBeModifiedForModification_ItemIEs_t *modifiedActionItemIe=NULLP;
+
+ modifyActionList->list.count = numOfActionToBeModify;
+ modifyActionList->list.size = modifyActionList->list.count * sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t*);
+ RIC_ALLOC(modifyActionList->list.array, modifyActionList->list.size);
+ if(!modifyActionList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx< modifyActionList->list.count; arrIdx++)
+ {
+ RIC_ALLOC(modifyActionList->list.array[arrIdx], sizeof(RICaction_ToBeModifiedForModification_ItemIEs_t));
+ if(!modifyActionList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+ modifiedActionItemIe = (RICaction_ToBeModifiedForModification_ItemIEs_t*)modifyActionList->list.array[arrIdx];
+ modifiedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeModifiedForModification_Item;
+ modifiedActionItemIe->criticality = CriticalityE2_ignore;
+ modifiedActionItemIe->value.present = RICaction_ToBeModifiedForModification_ItemIEs__value_PR_RICaction_ToBeModifiedForModification_Item;
+ modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionID = actionToBeModify[arrIdx].actionId;
+
+ /* RIC Action Definition */
+ RIC_ALLOC(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
+ if(!modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+
+ if(fillRicActionDef(modifiedActionItemIe->value.choice.RICaction_ToBeModifiedForModification_Item.ricActionDefinition,\
+ actionToBeModify[arrIdx].actionId, CONFIG_MOD) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+
+ }
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Build Ric subscription action to be removed list
+*
+* @details
+*
+* Function : BuildRicSubsActionToBeRemoved
+*
+* Functionality: Build Ric subscription action to be removed list
+*
+* @params[in]
+* RICactions_ToBeRemovedForModification_List_t to be filled
+* Num Of Action To Be Remove
+* Action remove list
+*
+* @return ROK - success
+* RFAILED - failure
+*
+******************************************************************/
+
+uint8_t BuildRicSubsActionToBeRemoved(RICactions_ToBeRemovedForModification_List_t *removeActionList, uint8_t numOfActionToBeRemove, ActionInfo *actionToBeRemove)
+{
+ uint8_t arrIdx=0;
+ RICaction_ToBeRemovedForModification_ItemIEs_t *removeActionItemIe=NULLP;
+
+ removeActionList->list.count = numOfActionToBeRemove;
+ removeActionList->list.size = removeActionList->list.count * sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t*);
+ RIC_ALLOC(removeActionList->list.array, removeActionList->list.size);
+ if(!removeActionList->list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx< removeActionList->list.count; arrIdx++)
+ {
+ RIC_ALLOC(removeActionList->list.array[arrIdx], sizeof(RICaction_ToBeRemovedForModification_ItemIEs_t));
+ if(!removeActionList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+ removeActionItemIe = (RICaction_ToBeRemovedForModification_ItemIEs_t*)removeActionList->list.array[arrIdx];
+ removeActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeRemovedForModification_Item;
+ removeActionItemIe->criticality = CriticalityE2_ignore;
+ removeActionItemIe->value.present = RICaction_ToBeRemovedForModification_ItemIEs__value_PR_RICaction_ToBeRemovedForModification_Item;
+ removeActionItemIe->value.choice.RICaction_ToBeRemovedForModification_Item.ricActionID = actionToBeRemove[arrIdx].actionId;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Build Ric subscription action to be added list
+*
+* @details
+*
+* Function : BuildRicSubsActionToBeAdded
+*
+* Functionality: Build Ric subscription action to be added list
+*
+* @params[in]
+* RICactions_ToBeAddedForModification_List_t to be filled
+* Num Of Action To Be added
+* Action add list
+*
+* @return ROK - success
+* RFAILED - failure
+*
+******************************************************************/
+
+uint8_t BuildRicSubsActionToBeAdded(RICactions_ToBeAddedForModification_List_t *addedActionList, RicSubscription **ricSubsInfo, uint8_t numOfActionToBeAdded, ActionInfo *actionToBeAdded)
+{
+ uint8_t arrIdx=0;
+ CmLList *actionNode=NULLP;
+ RICaction_ToBeAddedForModification_ItemIEs_t *addedActionItemIe;
+
+ addedActionList->list.count = numOfActionToBeAdded;
+ addedActionList->list.size = addedActionList->list.count * sizeof(RICaction_ToBeAddedForModification_ItemIEs_t*);
+ RIC_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++)
+ {
+ RIC_ALLOC(addedActionList->list.array[arrIdx], sizeof(RICaction_ToBeAddedForModification_ItemIEs_t));
+ if(!addedActionList->list.array[arrIdx])
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+ addedActionItemIe = (RICaction_ToBeAddedForModification_ItemIEs_t*)addedActionList->list.array[arrIdx];
+ addedActionItemIe->id = ProtocolIE_IDE2_id_RICaction_ToBeAddedForModification_Item;
+ addedActionItemIe->criticality = CriticalityE2_ignore;
+ addedActionItemIe->value.present = RICaction_ToBeAddedForModification_ItemIEs__value_PR_RICaction_ToBeAddedForModification_Item;
+ addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionID = actionToBeAdded[arrIdx].actionId;
+
+ addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionType = RICactionType_report;
+
+ if(fillRicActionDef(&addedActionItemIe->value.choice.RICaction_ToBeAddedForModification_Item.ricActionDefinition, \
+ actionToBeAdded[arrIdx].actionId, CONFIG_ADD) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+
+ actionNode = addRicSubsAction((*ricSubsInfo)->actionSequence.count, &(*ricSubsInfo)->actionSequence);
+ if(actionNode == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ return RFAILED;
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds and Send the RicSubscriptionModReq
+ *
+ * @details
+ *
+ * Function : BuildAndSendRicSubscriptionModReq
+ *
+ * Functionality:Builds and Send the RicSubscriptionModReq
+ *
+ * @params[in]
+ * Du databse
+ * Ric subs information
+ * List of ric subs action which needs to modify/add/remove
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t BuildAndSendRicSubscriptionModReq(DuDb *duDb, RicSubscription **ricSubsInfo, RicSubsModReq ricSubsModReq)
+{
+ uint8_t ret = RFAILED;
+ uint8_t elementCnt = 0;
+ uint8_t idx = 0;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+ E2AP_PDU_t *e2apRicMsg = NULL;
+ RICsubscriptionModificationRequest_t *ricSubscriptionModReq;
+
+ DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
+
+ while(true)
+ {
+ RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
+ if(e2apRicMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+
+ e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
+ RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ if(e2apRicMsg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModification;
+ e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
+ e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequest;
+
+ ricSubscriptionModReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequest;
+
+ /* Increasing the elment count based on the number of configured action to be add, mod, delete */
+ elementCnt = 2;
+ if(ricSubsModReq.numOfActionToBeAdded)
+ elementCnt++;
+ if(ricSubsModReq.numOfActionToBeModify)
+ elementCnt++;
+ if(ricSubsModReq.numOfActionToBeRemove)
+ elementCnt++;
+
+ ricSubscriptionModReq->protocolIEs.list.count = elementCnt;
+ ricSubscriptionModReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequest_IEs_t);
+
+ /* Initialize the subscription members */
+ RIC_ALLOC(ricSubscriptionModReq->protocolIEs.list.array, ricSubscriptionModReq->protocolIEs.list.size);
+ if(ricSubscriptionModReq->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+
+ for(idx=0; idx<elementCnt; idx++)
+ {
+ RIC_ALLOC(ricSubscriptionModReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionModificationRequest_IEs_t));
+ if(ricSubscriptionModReq->protocolIEs.list.array[idx] == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+ if(idx < elementCnt)
+ break;
+
+ /* Filling RIC Request Id */
+ idx = 0;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present =\
+ RICsubscriptionModificationRequest_IEs__value_PR_RICrequestID;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = (*ricSubsInfo)->requestId.requestorId;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = (*ricSubsInfo)->requestId.instanceId;
+
+ /* Filling RAN Function Id */
+ idx++;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present =\
+ RICsubscriptionModificationRequest_IEs__value_PR_RANfunctionID;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = (*ricSubsInfo)->ranFuncId;
+
+ if(ricSubsModReq.numOfActionToBeRemove)
+ {
+ /* Filling RIC Subscription action to be removed */
+ idx++;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeRemovedForModification_List;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeRemovedForModification_List;
+ if(BuildRicSubsActionToBeRemoved(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeRemovedForModification_List,\
+ ricSubsModReq.numOfActionToBeRemove, ricSubsModReq.actionToBeRemove) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+ if(ricSubsModReq.numOfActionToBeModify)
+ {
+ /* Filling RIC Subscription action to be modified */
+ idx++;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeModifiedForModification_List;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeModifiedForModification_List;
+ if(BuildRicSubsActionToBeModify(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeModifiedForModification_List,\
+ ricSubsModReq.numOfActionToBeModify, ricSubsModReq.actionToBeModify) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+
+ if(ricSubsModReq.numOfActionToBeAdded)
+ {
+ /* Filling RIC Subscription action to be added */
+ idx++;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionsToBeAddedForModification_List;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_ignore;
+ ricSubscriptionModReq->protocolIEs.list.array[idx]->value.present = RICsubscriptionModificationRequest_IEs__value_PR_RICactions_ToBeAddedForModification_List;
+ if(BuildRicSubsActionToBeAdded(&ricSubscriptionModReq->protocolIEs.list.array[idx]->value.choice.RICactions_ToBeAddedForModification_List,\
+ ricSubsInfo, ricSubsModReq.numOfActionToBeAdded, ricSubsModReq.actionToBeAdded) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
+ break;
+ }
+ }
+
+ /* Prints the Msg formed */
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
+
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionModRequest structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionModRequest\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ /* Sending msg */
+ if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
+ break;
+ }
+
+ ret = ROK;
+ break;
+ }
+
+ FreeRicSubscriptionModReq(e2apRicMsg);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds RicSubscriptionModReq
+ *
+ * @details
+ *
+ * Function : BuildRicSubscriptionModReq
+ *
+ * Functionality:Builds the RicSubscriptionModReq
+ *
+ * @params[in]
+ * Du databse
+ * @return void
+ *
+ * ****************************************************************/
+
+void BuildRicSubsModificationReq(DuDb *duDb, RicSubscription *ricSubsInfo)
+{
+ CmLList *actionNode=NULLP;
+ uint8_t actionToBeAdded =0;
+ uint8_t actionIdx =0, tmpActionIdx=0;
+ ActionInfo *actionInfoDb = NULLP;
+ RicSubsModReq ricSubsModReq;
+
+ if(ricSubsInfo)
+ {
+ memset(&ricSubsModReq, 0, sizeof(RicSubsModReq));
+
+
+ CM_LLIST_FIRST_NODE(&ricSubsInfo->actionSequence, actionNode);
+ while(actionNode)
+ {
+ actionInfoDb = (ActionInfo*)(actionNode->node);
+ /* Change the condition based on the action required to be modiified or removed */
+ if(((actionInfoDb->actionId+1)%2) == 0)
+ {
+ tmpActionIdx = ricSubsModReq.numOfActionToBeModify;
+ ricSubsModReq.actionToBeModify[tmpActionIdx].actionId = actionInfoDb->actionId;
+ ricSubsModReq.numOfActionToBeModify++;
+ }
+ else
+ {
+ tmpActionIdx = ricSubsModReq.numOfActionToBeRemove;
+ ricSubsModReq.actionToBeRemove[tmpActionIdx].actionId = actionInfoDb->actionId;
+ ricSubsModReq.numOfActionToBeRemove++;
+ }
+ actionNode= actionNode->next;
+ }
+ /* Change the value of actionToBeAdded based on the number of action required to be added */
+ actionToBeAdded =1;
+ tmpActionIdx = ricSubsInfo->actionSequence.count;
+ for(actionIdx=0; actionIdx<actionToBeAdded; actionIdx++)
+ {
+ ricSubsModReq.actionToBeAdded[actionIdx].actionId = tmpActionIdx;
+ ricSubsModReq.numOfActionToBeAdded++;
+ tmpActionIdx++;
+ }
+
+ if(BuildAndSendRicSubscriptionModReq(duDb, &ricSubsInfo, ricSubsModReq) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : failed to build and send RIC Subscription Modification");
+ return ;
+ }
+ }
+}
+
+/****************************************************************
+ *
+ * @brief Processing RIC Subscription action modified list
+ *
+ * @details
+ *
+ * Function :ProcessingRicSubsActionModified
+ *
+ * Functionality: Processing the RIC Subscription action modified list
+ *
+ * @params[in] RICactions_AddedForModification_List_t
+ * @return void
+ *
+ * ****************************************************************/
+void ProcessingRicSubsActionModified(RICactions_ModifiedForModification_List_t *actionModifiedList)
+{
+ uint8_t actionId=0;
+ uint8_t elementIdx = 0;
+ RICaction_ModifiedForModification_ItemIEs_t *modifiedActionItemIe =NULLP;
+
+ if(actionModifiedList->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionModifiedList->list.count; elementIdx++)
+ {
+ if(actionModifiedList->list.array[elementIdx])
+ {
+ modifiedActionItemIe=(RICaction_ModifiedForModification_ItemIEs_t*)actionModifiedList->list.array[elementIdx];
+ actionId = modifiedActionItemIe->value.choice.RICaction_ModifiedForModification_Item.ricActionID;
+ DU_LOG("\nInfo --> E2AP : Action id %d modified successfully", actionId);
+ }
+
+ }
+
+ }
+}
+
+/****************************************************************
+ *
+ * @brief Processing RIC Subscription action added list
+ *
+ * @details
+ *
+ * Function : ProcessingRicSubsActionAdded
+ *
+ * Functionality: Processing RIC Subscription action added list
+ *
+ * @params[in] RICactions_AddedForModification_List_t
+ * @return void
+ *
+ * ****************************************************************/
+void ProcessingRicSubsActionAdded(RICactions_AddedForModification_List_t *actionAddedList)
+{
+ uint8_t actionId=0;
+ uint8_t elementIdx = 0;
+ RICaction_AddedForModification_ItemIEs_t *addedActionItemIe =NULLP;
+
+ if(actionAddedList->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionAddedList->list.count; elementIdx++)
+ {
+ if(actionAddedList->list.array[elementIdx])
+ {
+ addedActionItemIe=(RICaction_AddedForModification_ItemIEs_t*)actionAddedList->list.array[elementIdx];
+ actionId = addedActionItemIe->value.choice.RICaction_AddedForModification_Item.ricActionID;
+ DU_LOG("\nInfo --> E2AP : Action id %d added successfully", actionId);
+ }
+
+ }
+
+ }
+}
+
+/****************************************************************
+ *
+ * @brief Processing RIC Subscription action deleted list
+ *
+ * @details
+ *
+ * Function : ProcessingRicSubsActionRemoved
+ *
+ * Functionality: Processing RIC Subscription action deleted list
+ *
+ * @params[in] RICactions_RemovedForModification_List_t
+ * Ric Subscription info
+ * @return void
+ *
+ * ****************************************************************/
+void ProcessingRicSubsActionRemoved(RICactions_RemovedForModification_List_t *actionRemovedList, RicSubscription *ricSubs)
+{
+ uint8_t actionId=0;
+ uint8_t elementIdx = 0;
+ ActionInfo *action=NULLP;
+ CmLList *actionNode =NULLP;
+ RICaction_RemovedForModification_ItemIEs_t *removedActionItemIe =NULLP;
+
+ if(actionRemovedList->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionRemovedList->list.count; elementIdx++)
+ {
+ if(actionRemovedList->list.array[elementIdx])
+ {
+ removedActionItemIe=(RICaction_RemovedForModification_ItemIEs_t*)actionRemovedList->list.array[elementIdx];
+ actionId = removedActionItemIe->value.choice.RICaction_RemovedForModification_Item.ricActionID;
+ action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
+ if(action)
+ {
+ cmLListDelFrm(&ricSubs->actionSequence, actionNode);
+ deleteActionSequence(actionNode);
+ DU_LOG("\nInfo --> E2AP : Action id %d removed successfully", actionId);
+ }
+ }
+
+ }
+
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Processing RIC Subscription action failed to be
+ * removed list
+ *
+ * @details
+ *
+ * Function : ProcessingRicSubsActionFailedToBeRemoved
+ *
+ * Functionality: Processing the RIC Subscription action failed
+ * to be removed list
+ *
+ * @params[in] RICactions_FailedToBeRemovedForModification_List_t
+ * @return void
+ *
+ * ****************************************************************/
+void ProcessingRicSubsActionFailedToBeRemoved(RICactions_FailedToBeRemovedForModification_List_t *actionFailedToBeRemoved)
+{
+ uint8_t actionId=0;
+ uint8_t elementIdx = 0;
+ RICaction_FailedToBeRemovedForModification_ItemIEs_t *failedToBeRemovedActionItemIe =NULLP;
+
+ if(actionFailedToBeRemoved->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionFailedToBeRemoved->list.count; elementIdx++)
+ {
+ if(actionFailedToBeRemoved->list.array[elementIdx])
+ {
+ failedToBeRemovedActionItemIe=(RICaction_FailedToBeRemovedForModification_ItemIEs_t*)actionFailedToBeRemoved->list.array[elementIdx];
+ actionId = failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.ricActionID;
+ DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId, __func__);
+ printE2ErrorCause(&failedToBeRemovedActionItemIe->value.choice.RICaction_FailedToBeRemovedForModification_Item.cause);
+ }
+
+ }
+
+ }
+}
+
+/****************************************************************
+ *
+ * @brief Processing RIC Subscription action failed to be
+ * add list
+ *
+ * @details
+ *
+ * Function : ProcessingRicSubsActionFailedToBeAdded
+ *
+ * Functionality: Processing the RIC Subscription action failed
+ * to be add list
+ *
+ * @params[in] RICactions_FailedToBeAddedForModification_List_t
+ * @return void
+ *
+ * ****************************************************************/
+void ProcessingRicSubsActionFailedToBeAdded(RICactions_FailedToBeAddedForModification_List_t *actionfailedToBeAddedList, RicSubscription *ricSubs)
+{
+ uint8_t actionId=0;
+ uint8_t elementIdx = 0;
+ ActionInfo *action=NULLP;
+ CmLList *actionNode =NULLP;
+ RICaction_FailedToBeAddedForModification_ItemIEs_t *failedToBeAddedActionItemIe =NULLP;
+
+ if(actionfailedToBeAddedList->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionfailedToBeAddedList->list.count; elementIdx++)
+ {
+ if(actionfailedToBeAddedList->list.array[elementIdx])
+ {
+ failedToBeAddedActionItemIe=(RICaction_FailedToBeAddedForModification_ItemIEs_t*)actionfailedToBeAddedList->list.array[elementIdx];
+ actionId = failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.ricActionID;
+ action = fetchActionInfoFromActionId(actionId, ricSubs, &actionNode);
+ if(action)
+ {
+ cmLListDelFrm(&ricSubs->actionSequence, actionNode);
+ deleteActionSequence(actionNode);
+ }
+ DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__);
+ printE2ErrorCause(&failedToBeAddedActionItemIe->value.choice.RICaction_FailedToBeAddedForModification_Item.cause);
+ }
+
+ }
+
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Processing RIC Subscription action failed to be
+ * modified list
+ *
+ * @details
+ *
+ * Function :ProcessingRicSubsActionFailedToBeModified
+ *
+ * Functionality: Processing the RIC Subscription action failed
+ * to be modified list
+ *
+ * @params[in] RICactions_FailedToBeModifiedForModification_List_t
+ * @return void
+ *
+ * ****************************************************************/
+void ProcessingRicSubsActionFailedToBeModified(RICactions_FailedToBeModifiedForModification_List_t *actionFailedToBeModifiedList)
+{
+ uint8_t actionId=0;
+ uint8_t elementIdx = 0;
+ RICaction_FailedToBeModifiedForModification_ItemIEs_t *failedToBeModifiedActionItemIe =NULLP;
+
+ if(actionFailedToBeModifiedList->list.array)
+ {
+ for(elementIdx = 0; elementIdx < actionFailedToBeModifiedList->list.count; elementIdx++)
+ {
+ if(actionFailedToBeModifiedList->list.array[elementIdx])
+ {
+ failedToBeModifiedActionItemIe=(RICaction_FailedToBeModifiedForModification_ItemIEs_t*)actionFailedToBeModifiedList->list.array[elementIdx];
+ actionId = failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.ricActionID;
+ DU_LOG("\nERROR --> E2AP : Failed to remove action id %d in %s", actionId,__func__);
+ printE2ErrorCause(&failedToBeModifiedActionItemIe->value.choice.RICaction_FailedToBeModifiedForModification_Item.cause);
+ }
+
+ }
+
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Processes the Ric Subs modification rsp msg
+ *
+ * @details
+ *
+ * Function : ProcRicSubsModificationRsp
+ *
+ * Functionality: Processes the Ric Subs modification rsp msg
+ *
+ * @params[in]
+ * Ric Subs modification rsp information
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void ProcRicSubsModificationRsp(uint32_t duId, RICsubscriptionModificationResponse_t *ricSubsModificationRsp)
+{
+ uint8_t ieIdx = 0;
+ uint8_t duIdx= 0;
+ uint16_t ranFuncId=0;
+ RanFunction *ranFuncDb = NULLP;
+ RicRequestId ricReqId;
+ DuDb *duDb = NULLP;
+ RicSubscription *ricSubs = NULLP;
+ CmLList *ricSubsNode = NULLP;
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
+ return;
+ }
+
+ if(!ricSubsModificationRsp)
+ {
+ DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp pointer is null");
+ return;
+ }
+
+ if(!ricSubsModificationRsp->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : ricSubsModificationRsp array pointer is null");
+ return;
+ }
+
+ for(ieIdx=0; ieIdx < ricSubsModificationRsp->protocolIEs.list.count; ieIdx++)
+ {
+ if(ricSubsModificationRsp->protocolIEs.list.array[ieIdx])
+ {
+ switch(ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_RICrequestID:
+ {
+ ricReqId.requestorId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricRequestorID;
+ ricReqId.instanceId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICrequestID.ricInstanceID;
+ break;
+ }
+ case ProtocolIE_IDE2_id_RANfunctionID:
+ {
+ ranFuncId = ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RANfunctionID;
+ ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
+ if(!ranFuncDb)
+ {
+ DU_LOG("\nERROR --> E2AP : Invalid Ran Function id %d received",ranFuncId);
+ return;
+ }
+
+ ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
+ if(!ricSubs)
+ {
+ DU_LOG("\nERROR --> E2AP : Ric subscription node is not present ");
+ return;
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsRemovedForModification_List:
+ {
+ ProcessingRicSubsActionRemoved(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_RemovedForModification_List, ricSubs);
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsFailedToBeRemovedForModification_List:
+ {
+ ProcessingRicSubsActionFailedToBeRemoved(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeRemovedForModification_List);
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsModifiedForModification_List:
+ {
+ ProcessingRicSubsActionModified(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_ModifiedForModification_List);
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsFailedToBeModifiedForModification_List:
+ {
+ ProcessingRicSubsActionFailedToBeModified(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeModifiedForModification_List);
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsAddedForModification_List:
+ {
+ ProcessingRicSubsActionAdded(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_AddedForModification_List);
+ break;
+ }
+ case ProtocolIE_IDE2_id_RICactionsFailedToBeAddedForModification_List:
+ {
+ ProcessingRicSubsActionFailedToBeAdded(&ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->value.choice.RICactions_FailedToBeAddedForModification_List, ricSubs);
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", ricSubsModificationRsp->protocolIEs.list.array[ieIdx]->id);
+ break;
+ }
+ }
+ }
+ }
+}
+
+/*******************************************************************
+*
+* @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;
+ }
+
+ DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
+ for(i=0; i< recvBufLen; i++)
+ {
+ DU_LOG("%x",recvBuf[i]);
+ }
+
+ /* 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);
+ RIC_FREE(recvBuf, (Size)recvBufLen);
+
+ if(rval.code == RC_FAIL || rval.code == RC_WMORE)
+ {
+ DU_LOG("\nERROR --> E2AP : ASN decode failed");
+ return;
+ }
+ DU_LOG("\n");
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
+
+ switch(e2apMsg->present)
+ {
+ case E2AP_PDU_PR_initiatingMessage:
+ {
+ switch(e2apMsg->choice.initiatingMessage->value.present)
+ {
+ case InitiatingMessageE2__value_PR_E2setupRequest:
+ {
+ DU_LOG("\nINFO --> E2AP : E2 setup request received");
+ ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
+ break;
+ }
+ case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
+ {
+ DU_LOG("\nINFO --> E2AP : E2 node config update received");
+ ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate);
+ break;
+ }
+ case InitiatingMessageE2__value_PR_ResetRequestE2:
+ {
+ DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
+ ProcResetRequest(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
+ break;
+ }
+ case InitiatingMessageE2__value_PR_RICindication:
+ {
+ DU_LOG("\nINFO --> E2AP : RIC Indication received");
+ break;
+ }