#include "E2SM-KPM-ActionDefinition.h"
#include "E2SM-KPM-EventTriggerDefinition-Format1.h"
#include "E2SM-KPM-EventTriggerDefinition.h"
+#include "E2connectionUpdate-Item.h"
/*******************************************************************
*
}
}
}
+/*******************************************************************
+ *
+ * @brief Delete E2 component node list
+ *
+ * @details
+ *
+ * Function : deleteE2ComponentNodeList
+ *
+ * Functionality: Delete E2 component node list
+ *
+ * @params[in] E2 component node list
+ * @return void
+
+ *
+ ******************************************************************/
+
+void deleteE2ComponentNodeList(CmLListCp *componentList)
+{
+ E2NodeComponent *cfgInfo = NULLP;
+ CmLList *e2ComponentNode = NULLP;
+
+ CM_LLIST_FIRST_NODE(componentList, e2ComponentNode);
+ while(e2ComponentNode)
+ {
+ cfgInfo = (E2NodeComponent*)e2ComponentNode->node;
+ cmLListDelFrm(componentList, e2ComponentNode);
+ memset(cfgInfo, 0, sizeof(E2NodeComponent));
+ CM_LLIST_FIRST_NODE(componentList, e2ComponentNode);
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief process the E2 node information from ric db
+ *
+ * @details
+ *
+ * Function : deleteE2NodeInfo
+ *
+ * Functionality: process the E2 node information from ric db
+ *
+ * @params[in]
+ * du Id
+ *
+ * @return void
+ *
+ ******************************************************************/
+void deleteE2NodeInfo(DuDb *duDb)
+{
+ uint16_t ranFuncIdx =0;
+ RanFunction *ranFuncDb=NULLP;
+
+ DU_LOG("\nINFO --> E2AP : Removing all the E2 node information");
+ for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
+ {
+ ranFuncDb = &duDb->ranFunction[ranFuncIdx];
+ if(ranFuncDb->id > 0)
+ {
+ deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
+ }
+ }
+ deleteE2ComponentNodeList(&duDb->e2NodeComponent);
+}
+
+/*******************************************************************
+ *
+ * @brief process the E2 Removal Response
+ *
+ * @details
+ *
+ * Function : ProcE2RemovalResponse
+ *
+ * Functionality: Process E2 Removal Response
+ *
+ * @params[in]
+ * du Id
+ * Pointer to removal response
+ * @return void
+ *
+ ******************************************************************/
+
+void ProcE2RemovalResponse(uint32_t duId, E2RemovalResponse_t *removalRsp)
+{
+ 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(!removalRsp)
+ {
+ DU_LOG("\nERROR --> E2AP : removalRsp pointer is null");
+ return;
+ }
+
+ if(!removalRsp->protocolIEs.list.array)
+ {
+ DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
+ return;
+ }
+
+ for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
+ {
+ if(removalRsp->protocolIEs.list.array[ieIdx])
+ {
+ switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_TransactionID:
+ {
+ DU_LOG("\nINFO --> E2AP : Sending request to close the sctp connection");
+ cmInetClose(&sctpCb.e2LstnSockFd);
+ deleteE2NodeInfo(duDb);
+ exit(0);
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> E2AP : Received Invalid Ie [%ld]", removalRsp->protocolIEs.list.array[ieIdx]->id);
+ break;
+ }
+ }
+ }
+ }
+}
+/*******************************************************************
+ *
+ * @brief Deallocate the memory allocated for E2 Removal Failure
+ *
+ * @details
+ *
+ * Function : FreeE2RemovalFailure
+ *
+ * Functionality:
+ * - freeing the memory allocated for E2RemovalFailure
+ *
+ * @params[in] E2AP_PDU_t *e2apMsg
+ * @return void
+ *
+ * ****************************************************************/
+void FreeE2RemovalFailure(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t ieIdx =0;
+ E2RemovalFailure_t *e2RemovalFailure=NULLP;
+
+ if(e2apMsg != NULLP)
+ {
+ if(e2apMsg->choice.unsuccessfulOutcome != NULLP)
+ {
+ e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
+ if(e2RemovalFailure->protocolIEs.list.array)
+ {
+ for(ieIdx=0; ieIdx < e2RemovalFailure->protocolIEs.list.count; ieIdx++)
+ {
+ if(e2RemovalFailure->protocolIEs.list.array[ieIdx])
+ {
+ RIC_FREE(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
+ }
+ }
+ RIC_FREE(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
+ }
+ RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
+ }
+ RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Buld and send the E2 Removal Failure msg
+ *
+ * @details
+ *
+ * Function : BuildAndSendE2RemovalFailure
+ *
+ * Functionality:
+ * - Buld and send the E2 Removal Failure Message
+ * @params[in]
+ * DU Id
+ * Trans Id
+ * Type of failure
+ * Cause of failure
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t BuildAndSendRemovalFailure(uint32_t duId, uint16_t transId, CauseE2_PR causePresent, uint8_t reason)
+{
+ uint8_t ieIdx = 0, elementCnt = 0;
+ uint8_t ret = RFAILED;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ E2RemovalFailure_t *e2RemovalFailure=NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+
+ DU_LOG("\nINFO --> E2AP : Building E2 Removal Failure Message\n");
+ do
+ {
+ 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_unsuccessfulOutcome;
+
+ RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
+ if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ break;
+ }
+
+ e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
+ e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
+ e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2RemovalFailure;
+ e2RemovalFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure;
+
+ elementCnt = 2;
+ e2RemovalFailure->protocolIEs.list.count = elementCnt;
+ e2RemovalFailure->protocolIEs.list.size = elementCnt * sizeof(E2RemovalFailureIEs_t *);
+ RIC_ALLOC(e2RemovalFailure->protocolIEs.list.array, e2RemovalFailure->protocolIEs.list.size);
+ if(!e2RemovalFailure->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(e2RemovalFailure->protocolIEs.list.array[ieIdx], sizeof(E2RemovalFailureIEs_t));
+ if(!e2RemovalFailure->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;
+ e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
+ e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
+ e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = E2RemovalFailureIEs__value_PR_TransactionID;
+ e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
+
+ /* Cause */
+ ieIdx++;
+ e2RemovalFailure->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
+ e2RemovalFailure->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
+ e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
+ fillE2FailureCause(&e2RemovalFailure->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
+
+ 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 removal 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 Removal Failure \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 Removal Failure");
+ break;
+ }
+
+ ret = ROK;
+ break;
+ }while(true);
+
+ FreeE2RemovalFailure(e2apMsg);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Deallocate the memory allocated for E2 Removal Response
+ *
+ * @details
+ *
+ * Function : FreeE2RemovalResponse
+ *
+ * Functionality:
+ * - freeing the memory allocated for E2RemovalResponse
+ *
+ * @params[in] E2AP_PDU_t *e2apMsg
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void FreeE2RemovalResponse(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t ieIdx =0;
+ E2RemovalResponse_t *e2RemovalResponse=NULLP;
+
+ if(e2apMsg != NULLP)
+ {
+ if(e2apMsg->choice.successfulOutcome != NULLP)
+ {
+ e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
+ if(e2RemovalResponse->protocolIEs.list.array)
+ {
+ for(ieIdx=0; ieIdx < e2RemovalResponse->protocolIEs.list.count; ieIdx++)
+ {
+ if(e2RemovalResponse->protocolIEs.list.array[ieIdx])
+ {
+ RIC_FREE(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
+ }
+ }
+ RIC_FREE(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
+ }
+ RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
+ }
+ RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Buld and send the E2 Removal Response msg
+ *
+ * @details
+ *
+ * Function : BuildAndSendE2RemovalResponse
+ *
+ * Functionality:
+ * - Buld and send the E2 Removal Response Message
+ * @params[in]
+ * Du Id
+ * Trans Id
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildAndSendRemovalResponse(uint32_t duId, uint16_t transId)
+{
+ uint8_t ieIdx = 0, elementCnt = 0;
+ uint8_t ret = RFAILED, duIdx =0;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ DuDb *duDb = NULLP;
+ E2RemovalResponse_t *e2RemovalResponse=NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+
+ DU_LOG("\nINFO --> E2AP : Building E2 Removal Response 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;
+ }
+
+ 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_successfulOutcome;
+
+ RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
+ if(e2apMsg->choice.successfulOutcome == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ break;
+ }
+
+ e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2removal;
+ e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
+ e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2RemovalResponse;
+ e2RemovalResponse = &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse;
+
+ elementCnt = 1;
+ e2RemovalResponse->protocolIEs.list.count = elementCnt;
+ e2RemovalResponse->protocolIEs.list.size = elementCnt * sizeof(E2RemovalResponseIEs_t *);
+ RIC_ALLOC(e2RemovalResponse->protocolIEs.list.array, e2RemovalResponse->protocolIEs.list.size);
+ if(!e2RemovalResponse->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(e2RemovalResponse->protocolIEs.list.array[ieIdx], sizeof(E2RemovalResponseIEs_t));
+ if(!e2RemovalResponse->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;
+ e2RemovalResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
+ e2RemovalResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
+ e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.present = E2RemovalResponseIEs__value_PR_TransactionID;
+ e2RemovalResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
+
+ 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 removal response structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Removal Response \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 Removal Response");
+ break;
+ }
+
+ ret = ROK;
+ break;
+ }while(true);
+
+ FreeE2RemovalResponse(e2apMsg);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Process Removal req received from RIC
+ *
+ * @details
+ *
+ * Function : procE2RemovalRequest
+ *
+ * Functionality: Process Removal req received from RIC
+ *
+ * @param
+ * DU id
+ * E2 Removal Request
+ * @return void
+ *
+ ******************************************************************/
+
+void procE2RemovalRequest(uint32_t duId, E2RemovalRequest_t *removalReq)
+{
+ uint8_t arrIdx =0;
+ uint16_t transId =0;
+
+ DU_LOG("\nINFO --> E2AP : E2 Removal request received");
+
+ for(arrIdx=0; arrIdx<removalReq->protocolIEs.list.count; arrIdx++)
+ {
+ switch(removalReq->protocolIEs.list.array[arrIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_TransactionID:
+ {
+ transId = removalReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> E2AP : Invalid IE recevied [%d]", transId);
+ break;
+ }
+ }
+ }
+
+ if(transId>=0 && transId<=255)
+ {
+ if(BuildAndSendRemovalResponse(duId, transId) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
+ }
+ }
+ else
+ {
+ if(BuildAndSendRemovalFailure(duId, transId, CauseE2_PR_protocol, CauseE2Protocol_abstract_syntax_error_falsely_constructed_message) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to build and send Removal response");
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief fill E2 connection update item
+ *
+ * @details
+ *
+ * Function : fillE2connectionUpdateItem
+ *
+ * Functionality: fill E2 connection update item
+ *
+ * @params[in]
+ * E2connectionUpdate Item to be filled
+ * Protocol Id
+ * @return ROK - success
+ * RFAILED - failure
+ * ****************************************************************/
+
+uint8_t fillE2connectionUpdateItem(PTR connectionInfo, uint8_t protocolId)
+{
+ E2connectionUpdateRemove_Item_t *connectionRemoveITem=NULLP;
+ E2connectionUpdate_Item_t *connectionModifyItem=NULLP;
+ TNLinformation_t *tnlInformation = NULLP;
+ TNLusage_t *tnlUsage=NULLP;
+
+ switch(protocolId)
+ {
+ case ProtocolIE_IDE2_id_E2connectionUpdate_Item:
+ {
+ connectionModifyItem = (E2connectionUpdate_Item_t*)connectionInfo;
+ tnlInformation = &connectionModifyItem->tnlInformation;
+ tnlUsage = &connectionModifyItem->tnlUsage;
+ break;
+ }
+
+ case ProtocolIE_IDE2_id_E2connectionUpdateRemove_Item:
+ {
+ connectionRemoveITem = (E2connectionUpdateRemove_Item_t*)connectionInfo;
+ tnlInformation= &connectionRemoveITem->tnlInformation;
+ break;
+ }
+ }
+
+ tnlInformation->tnlAddress.size = 4*sizeof(uint8_t);
+ RIC_ALLOC(tnlInformation->tnlAddress.buf, tnlInformation->tnlAddress.size);
+ if(!tnlInformation->tnlAddress.buf)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+
+ tnlInformation->tnlAddress.buf[3] = ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr & 0xFF;
+ tnlInformation->tnlAddress.buf[2] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 8) & 0xFF;
+ tnlInformation->tnlAddress.buf[1] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 16) & 0xFF;
+ tnlInformation->tnlAddress.buf[0] = (ricCb.ricCfgParams.sctpParams.localIpAddr.ipV4Addr>> 24) & 0xFF;
+ tnlInformation->tnlAddress.bits_unused = 0;
+ if(protocolId == ProtocolIE_IDE2_id_E2connectionUpdate_Item)
+ {
+ *tnlUsage = TNLusage_support_function;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Build E2 connection modification list
+ *
+ * @details
+ *
+ * Function : BuildE2ConnectionModifyList
+ *
+ * Functionality: Build E2 connection modification list
+ *
+ * @params[in]
+ * E2 connection modification list to be filled
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ * ****************************************************************/
+
+uint8_t BuildE2ConnectionModifyList(E2connectionUpdate_List_t *connectionToBeModifyList)
+{
+ uint8_t arrIdx = 0;
+ E2connectionUpdate_ItemIEs_t *connectionModify=NULL;
+
+ connectionToBeModifyList->list.count = 1;
+
+ connectionToBeModifyList->list.size = connectionToBeModifyList->list.count*sizeof(E2connectionUpdate_ItemIEs_t*);
+ RIC_ALLOC(connectionToBeModifyList->list.array, connectionToBeModifyList->list.size);
+ if(connectionToBeModifyList->list.array)
+ {
+ for(arrIdx = 0; arrIdx< connectionToBeModifyList->list.count; arrIdx++)
+ {
+ RIC_ALLOC(connectionToBeModifyList->list.array[arrIdx], sizeof(E2connectionUpdate_ItemIEs_t));
+ if(connectionToBeModifyList->list.array[arrIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
+ return RFAILED;
+ }
+ connectionModify = (E2connectionUpdate_ItemIEs_t*)connectionToBeModifyList->list.array[arrIdx];
+ connectionModify->id = ProtocolIE_IDE2_id_E2connectionUpdate_Item;
+ connectionModify->criticality= CriticalityE2_ignore;
+ connectionModify->value.present = E2connectionUpdate_ItemIEs__value_PR_E2connectionUpdate_Item;
+ if(fillE2connectionUpdateItem((PTR)&connectionModify->value.choice.E2connectionUpdate_Item, ProtocolIE_IDE2_id_E2connectionUpdate_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 Build E2 connection remove list
+ *
+ * @details
+ *
+ * Function : BuildE2ConnectionRemoveList
+ *
+ * Functionality: Build E2 connection remove list
+ *
+ * @params[in]
+ * E2 connection remove list to be filled
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ * ****************************************************************/
+
+uint8_t BuildE2ConnectionRemoveList(E2connectionUpdateRemove_List_t *connectionToBeRemoveList)
+{
+ uint8_t arrIdx = 0;
+ E2connectionUpdateRemove_ItemIEs_t *connectionRemove=NULL;
+
+ connectionToBeRemoveList->list.count = 1;
+
+ connectionToBeRemoveList->list.size = connectionToBeRemoveList->list.count*sizeof(E2connectionUpdateRemove_ItemIEs_t*);
+ RIC_ALLOC(connectionToBeRemoveList->list.array, connectionToBeRemoveList->list.size);
+ if(connectionToBeRemoveList->list.array)
+ {
+ for(arrIdx = 0; arrIdx< connectionToBeRemoveList->list.count; arrIdx++)
+ {
+ RIC_ALLOC(connectionToBeRemoveList->list.array[arrIdx], sizeof(E2connectionUpdateRemove_ItemIEs_t));
+ if(connectionToBeRemoveList->list.array[arrIdx] == NULLP)
+ {
+ 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 process the E2 node information from ric db
+ * @brief Processes the E2 connection update failure msg
*
* @details
*
- * Function : deleteE2NodeInfo
+ * Function : procE2connectionUpdateFailure
*
- * Functionality: process the E2 node information from ric db
+ * Functionality: Processes the E2 connection update failure msg
*
* @params[in]
- * du Id
- *
+ * E2 connection update failure information
+ *
* @return void
*
- ******************************************************************/
-void deleteE2NodeInfo(DuDb *duDb)
+ * ****************************************************************/
+void ProcE2connectionUpdateFailure(E2connectionUpdateFailure_t *updateFailure)
{
- uint16_t ranFuncIdx =0;
- RanFunction *ranFuncDb=NULLP;
+ uint8_t ieIdx = 0;
+ uint16_t transId=0;
+ CauseE2_t *cause = NULLP;
- DU_LOG("\nINFO --> E2AP : Removing all the E2 node information");
- for(ranFuncIdx = 0; ranFuncIdx < MAX_RAN_FUNCTION; ranFuncIdx++)
+ if(!updateFailure)
{
- ranFuncDb = &duDb->ranFunction[ranFuncIdx];
- if(ranFuncDb->id > 0)
+ 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])
{
- deleteRicSubscriptionList(&ranFuncDb->subscriptionList);
+ 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 [%d]", updateFailure->protocolIEs.list.array[ieIdx]->id);
+ break;
+ }
+ }
}
}
-
- cmInetClose(&sctpCb.e2LstnSockFd);
}
/*******************************************************************
*
- * @brief process the E2 Removal Response
+ * @brief process the E2 Connection update ack
*
* @details
*
- * Function : ProcRemovalResponse
+ * Function : ProcE2ConnectionUpdateAck
*
- * Functionality: Process E2 Removal Response
+ * Functionality: Process E2 Connection update ack
*
* @params[in]
* du Id
- * Pointer to removal response
+ * Pointer to Connection update ack
* @return void
*
******************************************************************/
-void ProcRemovalResponse(uint32_t duId, E2RemovalResponse_t *removalRsp)
+void ProcE2ConnectionUpdateAck(uint32_t duId, E2connectionUpdateAcknowledge_t *connectionUpdateAck)
{
- uint8_t ieIdx = 0, duIdx =0;
+ uint16_t transId =0;
+ uint32_t ipAddress=0;
DuDb *duDb = NULLP;
- RanFunction *ranFuncDb = NULLP;
- uint16_t ranFuncIdx = 0;
+ 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)
return;
}
- if(!removalRsp)
+ if(!connectionUpdateAck)
{
- DU_LOG("\nERROR --> E2AP : removalRsp pointer is null");
+ DU_LOG("\nERROR --> E2AP : connectionUpdateAck pointer is null");
return;
}
- if(!removalRsp->protocolIEs.list.array)
+ if(!connectionUpdateAck->protocolIEs.list.array)
{
- DU_LOG("\nERROR --> E2AP : removalRsp array pointer is null");
+ DU_LOG("\nERROR --> E2AP : connectionUpdateAck array pointer is null");
return;
}
- for(ieIdx=0; ieIdx < removalRsp->protocolIEs.list.count; ieIdx++)
+ for(ieIdx=0; ieIdx < connectionUpdateAck->protocolIEs.list.count; ieIdx++)
{
- if(removalRsp->protocolIEs.list.array[ieIdx])
+ if(connectionUpdateAck->protocolIEs.list.array[ieIdx])
{
- switch(removalRsp->protocolIEs.list.array[ieIdx]->id)
+ switch(connectionUpdateAck->protocolIEs.list.array[ieIdx]->id)
{
case ProtocolIE_IDE2_id_TransactionID:
{
- deleteE2NodeInfo(duDb);
+ 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]", removalRsp->protocolIEs.list.array[ieIdx]->id);
+ 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;
}
}
DU_LOG("\nINFO --> E2AP : Error indication received");
break;
}
+ case InitiatingMessageE2__value_PR_E2RemovalRequest:
+ {
+ DU_LOG("\nINFO --> E2AP : E2 Removal request received");
+ procE2RemovalRequest(*duId,\
+ &e2apMsg->choice.initiatingMessage->value.choice.E2RemovalRequest);
+ break;
+ }
default:
{
DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \
}
case SuccessfulOutcomeE2__value_PR_E2RemovalResponse:
{
- ProcRemovalResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse);
+ ProcE2RemovalResponse(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2RemovalResponse);
+ break;
+ }
+ case SuccessfulOutcomeE2__value_PR_E2connectionUpdateAcknowledge:
+ {
+ ProcE2ConnectionUpdateAck(*duId, &e2apMsg->choice.successfulOutcome->value.choice.E2connectionUpdateAcknowledge);
+ break;
+ }
+ case SuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteResponse:
+ {
+ ProcRicSubsDeleteRsp(*duId, &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionDeleteResponse);
break;
}
default:
ProcE2RemovalFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.E2RemovalFailure);
break;
}
+ case UnsuccessfulOutcomeE2__value_PR_E2connectionUpdateFailure:
+ {
+ ProcE2connectionUpdateFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.E2connectionUpdateFailure);
+ break;
+ }
+ case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionDeleteFailure:
+ {
+ ProcRicSubsDeleteFailure(&e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure);
+ break;
+ }
default:
{
DU_LOG("\nERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \
Code Review / o-du / l2.git / blobdiff