X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fric_stub%2Fric_e2ap_msg_hdl.c;h=f9540ce22872433093867b01901a438876ad79db;hb=c371a26d48604a5d60686d9ca347e68671e69637;hp=5f8b1156339e02a979e2159b7b300217b081d400;hpb=5b669934530a541a73f027aff9be4269a5fd6b52;p=o-du%2Fl2.git diff --git a/src/ric_stub/ric_e2ap_msg_hdl.c b/src/ric_stub/ric_e2ap_msg_hdl.c index 5f8b11563..f9540ce22 100644 --- a/src/ric_stub/ric_e2ap_msg_hdl.c +++ b/src/ric_stub/ric_e2ap_msg_hdl.c @@ -42,6 +42,7 @@ #include "E2SM-KPM-ActionDefinition.h" #include "E2SM-KPM-EventTriggerDefinition-Format1.h" #include "E2SM-KPM-EventTriggerDefinition.h" +#include "E2connectionUpdate-Item.h" /******************************************************************* * @@ -5982,64 +5983,1009 @@ void ProcE2RemovalFailure(E2RemovalFailure_t *e2RemovalFailure) } } } +/******************************************************************* + * + * @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; arrIdxprotocolIEs.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) @@ -6048,32 +6994,225 @@ void ProcRemovalResponse(uint32_t duId, E2RemovalResponse_t *removalRsp) 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; } } @@ -6202,6 +7341,13 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) 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]", \ @@ -6229,7 +7375,17 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) } 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: @@ -6257,6 +7413,16 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) 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]", \