X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fric_stub%2Fric_e2ap_msg_hdl.c;h=0d8555c1af05edb0a57b651f0f9653c7130f3a8c;hb=76d2662c441ac10d75d004698ae6ca6a61814d72;hp=6060f9c2d6c3cd6d20f000ed9d6dfe07be11f17b;hpb=cff10ba79a0f18dcf3aa6675a11b56e8d7ffb6b8;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 6060f9c2d..0d8555c1a 100644 --- a/src/ric_stub/ric_e2ap_msg_hdl.c +++ b/src/ric_stub/ric_e2ap_msg_hdl.c @@ -37,6 +37,12 @@ #include "RIC-EventTriggerStyle-Item.h" #include "RIC-ReportStyle-Item.h" #include "MeasurementInfo-Action-Item.h" +#include "MeasurementInfoItem.h" +#include "E2SM-KPM-ActionDefinition-Format1.h" +#include "E2SM-KPM-ActionDefinition.h" +#include "E2SM-KPM-EventTriggerDefinition-Format1.h" +#include "E2SM-KPM-EventTriggerDefinition.h" + /******************************************************************* * @@ -94,7 +100,7 @@ uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId) if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK) { ODU_PRINT_MSG(mBuf, 0,0); - + if(sctpSend(duId, mBuf) != ROK) { DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed"); @@ -115,10 +121,228 @@ uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId) DU_LOG("\nERROR --> E2AP : Failed to allocate memory"); return RFAILED; } - + return ROK; } /* SendE2APMsg */ +/******************************************************************* + * + * @brief deallocate memory allocated in E2 Node Config Update Failure + * + * @details + * + * Function : FreeE2ConfigUpdateFail + * + * Functionality: deallocate memory allocated in E2 Node Config Update Failure + * + * @params[in] E2AP_PDU_t *e2apMsg + * + * @return void + * ****************************************************************/ + +void FreeE2ConfigUpdateFail(E2AP_PDU_t *e2apMsg) +{ + uint8_t arrIdx = 0; + E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL; + + if(e2apMsg) + { + if(e2apMsg->choice.unsuccessfulOutcome) + { + e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure; + if(e2NodeCfgUpdFail->protocolIEs.list.array) + { + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + { + RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateFailure_IEs_t)); + } + RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array, e2NodeCfgUpdFail->protocolIEs.list.size); + } + RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t)); + } + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* + * + * @brief Buld and send the E2 Node Config Update failure + * + * @details + * + * Function : BuildAndSendE2NodeConfigUpdateFailure + * + * Functionality: + * - Buld and send the E2 Node Config Update failure + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t BuildAndSendE2NodeConfigUpdateFailure(uint32_t duId, uint8_t transId, uint8_t causeInfo, uint8_t causeReason) +{ + E2AP_PDU_t *e2apMsg = NULL; + asn_enc_rval_t encRetVal; + uint8_t arrIdx=0; + uint8_t elementCnt=0; + bool memAllocFailed = false; + E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdateFail=NULL; + + DU_LOG("\nINFO --> E2AP : Building E2 Node Config Update failure\n"); + while(true) + { + RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); + if(e2apMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + break; + } + e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome; + RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2)); + if(e2apMsg->choice.unsuccessfulOutcome == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + break; + } + + e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate; + e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject; + e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure; + e2NodeCfgUpdateFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure; + + elementCnt = 3; + e2NodeCfgUpdateFail->protocolIEs.list.count = elementCnt; + e2NodeCfgUpdateFail->protocolIEs.list.size = elementCnt * sizeof(struct E2nodeConfigurationUpdateFailure_IEs *); + + RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array, e2NodeCfgUpdateFail->protocolIEs.list.size); + if(e2NodeCfgUpdateFail->protocolIEs.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure array failed"); + break; + } + + for(arrIdx=0; arrIdxprotocolIEs.list.array[arrIdx], sizeof(struct E2nodeConfigurationUpdateFailure_IEs)); + if(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure IEs failed"); + memAllocFailed = true; + break; + } + } + + if(memAllocFailed == true) + { + break; + } + + /* Trans Id */ + arrIdx = 0; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId; + + arrIdx++; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = causeInfo; + if(causeInfo == CauseE2_PR_e2Node) + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.e2Node = causeReason; + else + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.misc = causeReason; + + arrIdx++; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2; + e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s; + + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf); + + /* Check encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode E2 Node Config Update failure structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node Config Update Failure\n"); + for(int i=0; i< encBufSize; i++) + { + DU_LOG("%x",encBuf[i]); + } + } + + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) + { + DU_LOG("\nERROR --> E2AP : Sending E2 Node Config Update Failure failed"); + break; + } + break; + } + + FreeE2ConfigUpdateFail(e2apMsg); + return ROK; +} + +/******************************************************************* + * + * @brief process the E2 node configuration update + * + * @details + * + * Function : ProcE2NodeConfigUpdate + * + * Functionality: Process E2 node configuration update + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +void ProcE2NodeConfigUpdate(uint32_t duId, E2nodeConfigurationUpdate_t *e2NodeConfigUpdate) +{ + uint8_t ieIdx = 0, duIdx = 0; + uint8_t transId = 0, e2NodeUpdateListIdx=0; + DuDb *duDb = NULLP; + E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList=NULLP; + E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe=NULLP; + E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULLP; + + if(e2NodeConfigUpdate) + { + if(e2NodeConfigUpdate->protocolIEs.list.array) + { + for(ieIdx=0; ieIdx < e2NodeConfigUpdate->protocolIEs.list.count; ieIdx++) + { + if(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]) + { + switch(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_TransactionID: + transId = e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID; + break; + + default: + { + /*TODO - Other IEs will be handling in next gerrit*/ + break; + } + } + } + } + } + } +} + /******************************************************************* * * @brief Builds Global RIC Id Params @@ -170,11 +394,11 @@ uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId) void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg) { uint8_t arrIdx = 0, e2NodeConfigIdx=0, ranFuncIdx=0; - RANfunctionsID_List_t *ranFuncAddedList; - E2setupResponse_t *e2SetupRsp; - E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe; - E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList; - E2nodeComponentInterfaceF1_t *f1InterfaceInfo; + RANfunctionsID_List_t *ranFuncAcceptedList=NULL; + E2setupResponse_t *e2SetupRsp=NULL; + E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULL; + E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULL; + E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULL; if(e2apMsg) { @@ -189,17 +413,17 @@ void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg) { case ProtocolIE_IDE2_id_RANfunctionsAccepted: { - ranFuncAddedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List; - if(ranFuncAddedList->list.array) + ranFuncAcceptedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List; + if(ranFuncAcceptedList->list.array) { - for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) + for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) { - if(ranFuncAddedList->list.array[ranFuncIdx]) + if(ranFuncAcceptedList->list.array[ranFuncIdx]) { - RIC_FREE(ranFuncAddedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t)); + RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t)); } } - RIC_FREE(ranFuncAddedList->list.array, ranFuncAddedList->list.size); + RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size); } break; } @@ -312,13 +536,13 @@ uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_L /******************************************************************* * - * @brief Build RAN function added list + * @brief Build RAN function accepted list * * @details * - * Function : BuildRanFunctionAddedList + * Function : BuildRanFunctionAcceptedList * - * Functionality: Build RAN function added list + * Functionality: Build RAN function accepted list * ->For ProcedureCodeE2_id_E2setup or ProcedureCodeE2_id_RICserviceQuery * we add all the RAN Function list which is present in RIC database. * ->For any other procedures, we just fill the RAN functions whose ID @@ -326,7 +550,7 @@ uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_L * * @params[in] * Stored DU databse - * Count of ran functions to be added in the list + * Count of ran functions to be accepted in the list * Received list of RAN functions * RAN Function list * Procedure Code @@ -335,10 +559,10 @@ uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_L * RFAILED - failure * ****************************************************************/ -uint8_t BuildRanFunctionAddedList(DuDb *duDb, uint8_t count, RanFunction *ranFunToBeAdded, RANfunctionsID_List_t *ranFuncAddedList, uint8_t procedureCode) +uint8_t BuildRanFunctionAcceptedList(DuDb *duDb, uint8_t count, RanFunction *ranFunAcceptedList, RANfunctionsID_List_t *ranFuncAcceptedList, uint8_t procedureCode) { uint8_t ranFuncIdx = 0; - RANfunctionID_ItemIEs_t *ranFuncAddedItemIe; + RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL; /* For ProcedureCodeE2_id_E2setup and ProcedureCodeE2_id_RICserviceQuery, * the number of RAN function list items is equal to the number of @@ -347,37 +571,37 @@ uint8_t BuildRanFunctionAddedList(DuDb *duDb, uint8_t count, RanFunction *ranFun * to the count of ran functions obtained from the function's caller */ if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup)) - ranFuncAddedList->list.count = duDb->numOfRanFunction; + ranFuncAcceptedList->list.count = duDb->numOfRanFunction; else - ranFuncAddedList->list.count = count; + ranFuncAcceptedList->list.count = count; - ranFuncAddedList->list.size = ranFuncAddedList->list.count*sizeof(RANfunctionID_ItemIEs_t*); - RIC_ALLOC(ranFuncAddedList->list.array, ranFuncAddedList->list.size); - if(ranFuncAddedList->list.array) + ranFuncAcceptedList->list.size = ranFuncAcceptedList->list.count*sizeof(RANfunctionID_ItemIEs_t*); + RIC_ALLOC(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size); + if(ranFuncAcceptedList->list.array) { - for(ranFuncIdx = 0; ranFuncIdx< ranFuncAddedList->list.count; ranFuncIdx++) + for(ranFuncIdx = 0; ranFuncIdx< ranFuncAcceptedList->list.count; ranFuncIdx++) { - RIC_ALLOC(ranFuncAddedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t)); - if(ranFuncAddedList->list.array[ranFuncIdx] == NULLP) + RIC_ALLOC(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t)); + if(ranFuncAcceptedList->list.array[ranFuncIdx] == NULLP) { DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array item"); return RFAILED; } - ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx]; - ranFuncAddedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item; - ranFuncAddedItemIe->criticality= CriticalityE2_ignore; - ranFuncAddedItemIe->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item; + ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[ranFuncIdx]; + ranFuncAcceptedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item; + ranFuncAcceptedItemIe->criticality= CriticalityE2_ignore; + ranFuncAcceptedItemIe->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item; if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup)) { /* filling the RAN function information with the help of DuDb */ - ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = duDb->ranFunction[ranFuncIdx].id; - ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= duDb->ranFunction[ranFuncIdx].revisionCounter; + ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = duDb->ranFunction[ranFuncIdx].id; + ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= duDb->ranFunction[ranFuncIdx].revisionCounter; } else { /* filling the the RAN function information with the help received list of RAN functions */ - ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = ranFunToBeAdded[ranFuncIdx].id; - ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= ranFunToBeAdded[ranFuncIdx].revisionCounter; + ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = ranFunAcceptedList[ranFuncIdx].id; + ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= ranFunAcceptedList[ranFuncIdx].revisionCounter; } } } @@ -482,8 +706,7 @@ uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId) idx++; e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID; e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - e2SetupRsp->protocolIEs.list.array[idx]->value.present = \ - E2setupResponseIEs__value_PR_GlobalRIC_ID; + e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_GlobalRIC_ID; if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK) { @@ -498,7 +721,7 @@ uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId) e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted; e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List; - if(BuildRanFunctionAddedList(duDb, 0, NULL, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_E2setup)!=ROK) + if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_E2setup)!=ROK) { DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list"); break; @@ -510,8 +733,9 @@ uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId) e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck; e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; e2SetupRsp->protocolIEs.list.array[idx]->value.present = \ - E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List; - if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->value.choice.E2nodeComponentConfigAdditionAck_List, duDb)!=ROK) + E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List; + if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->\ + value.choice.E2nodeComponentConfigAdditionAck_List, duDb) != ROK) { DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list"); break; @@ -547,342 +771,1524 @@ uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId) } FreeE2SetupRsp(e2apMsg); - BuildAndSendRicSubscriptionReq(duDb->duId); + BuildAndSendRicSubscriptionReq(duDb); return ROK; } /******************************************************************* * - * @brief Builds Ric Request Id + * @brief Free RIC Subscription Details * * @details * - * Function : BuildRicRequestId + * Function : FreeRicSubsDetails * - * Functionality: Building the Ric Request Id + * Functionality: Free the RIC Subscription Details * - * @params[in] RICrequestID_t *ricReqId - * @return ROK - success - * RFAILED - failure + * @params[in] RICsubscriptionDetails_t *subsDetails + * @return void * * ****************************************************************/ - -uint8_t BuildRicRequestId(RICrequestID_t *ricReqId) +void FreeRicSubsDetails(RICsubscriptionDetails_t *subsDetails) { + uint8_t elementIdx = 0; + RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP; - if(ricReqId != NULLP) + RIC_FREE(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size); + + if(subsDetails->ricAction_ToBeSetup_List.list.array) { - ricReqId->ricRequestorID = 1; - ricReqId->ricInstanceID = 1; + for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++) + { + if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]) + { + actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]; + if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) + { + RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf, \ + actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size); + RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t)); + } + RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t)) + } + } + RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size); } - return ROK; } /******************************************************************* * - * @brief Fills Ric Action To be Setup Item + * @brief Free RIC Subscription Request * * @details * - * Function : fillSetupItems + * Function : FreeRicSubscriptionReq * - * Functionality: Filling ricAction Id, RicActionType + * Functionality : Free RIC Subscription Request * - * @params[in] RICaction_ToBeSetup_Item_t *setupItems - * @return pointer of type RICaction_ToBeSetup_Item_t + * @return ROK - success + * RFAILED - failure * - * ****************************************************************/ - -RICaction_ToBeSetup_Item_t* fillSetupItems(RICaction_ToBeSetup_Item_t *setupItems) + ******************************************************************/ +void FreeRicSubscriptionReq(E2AP_PDU_t *e2apRicMsg) { - if(setupItems != NULLP) + uint8_t idx = 0; + RICsubscriptionRequest_t *ricSubscriptionReq; + + if(e2apRicMsg) { - setupItems->ricActionID = 0; - setupItems->ricActionType = RICactionType_report; + if(e2apRicMsg->choice.initiatingMessage) + { + ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest; + if(ricSubscriptionReq->protocolIEs.list.array) + { + for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++) + { + switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id) + { + case ProtocolIE_IDE2_id_RICsubscriptionDetails: + { + FreeRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails)); + break; + } + } + RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t)); + } + RIC_FREE(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size); + } + RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + } + RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t)); } - - return (setupItems); } /******************************************************************* * - * @brief Fills RIC Subscription Details Item List + * @brief Builds Ric Request Id * * @details * - * Function : fillSubsDetails + * Function : BuildNewRicRequestId * - * Functionality: Fill the RIC Subscription Details Items List + * Functionality: Assign new Ric Request ID * - * @params[in] RICaction_ToBeSetup_ItemIEs_t *items + * @params[in] RIC request ID to be sent + * RIC request ID stored in DB * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t fillSubsDetails(RICaction_ToBeSetup_ItemIEs_t *items) +uint8_t BuildNewRicRequestId(RICrequestID_t *ricReqId, RicRequestId *reqIdDb) { - if(items != NULLP) + static uint16_t requestorId = 0; + static uint16_t instanceId = 0; + + if(ricReqId != NULLP) { - items->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item; - items->criticality = CriticalityE2_ignore; - items->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item; - fillSetupItems(&(items->value.choice.RICaction_ToBeSetup_Item)); + ricReqId->ricRequestorID = ++requestorId; + ricReqId->ricInstanceID = ++instanceId; + + reqIdDb->requestorId = ricReqId->ricRequestorID; + reqIdDb->instanceId = ricReqId->ricInstanceID; } return ROK; } /******************************************************************* * - * @brief builds RIC Subscription Details + * @brief Free RIC Action Definition * * @details * - * Function : BuildsRicSubsDetails + * Function : FreeRicActionDefinition * - * Functionality: Builds the RIC Subscription Details + * Functionality: Free RIC Action Definition * - * @params[in] RICsubscriptionDetails_t *subsDetails - * @return ROK - success - * RFAILED - failure + * @params[in] E2SM-KPM Action definition + * @return void * * ****************************************************************/ - -uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails) +void FreeRicActionDefinition(E2SM_KPM_ActionDefinition_t actionDef) { + uint8_t elementIdx = 0; + E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP; + MeasurementInfoItem_t *measItem = NULLP; - uint8_t elementCnt; - - if(subsDetails != NULLP) + switch(actionDef.actionDefinition_formats.present) { - /* Octet string to be build here */ - /* Sending PLMN as Octect string */ - uint8_t byteSize = 3; - subsDetails->ricEventTriggerDefinition.size = byteSize * sizeof(uint8_t); - RIC_ALLOC(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size); - buildPlmnId(ricCb.ricCfgParams.plmn, subsDetails->ricEventTriggerDefinition.buf); - elementCnt = 1; - subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt; - subsDetails->ricAction_ToBeSetup_List.list.size = \ - elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t); - RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, \ - subsDetails->ricAction_ToBeSetup_List.list.size); - if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed"); - return RFAILED; - } - RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[0],\ - sizeof(RICaction_ToBeSetup_ItemIEs_t)); - fillSubsDetails(subsDetails->ricAction_ToBeSetup_List.list.array[0]); + case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1: + { + if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1) + { + actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1; + if(actionFormat1->measInfoList.list.array) + { + for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++) + { + if(actionFormat1->measInfoList.list.array[elementIdx]) + { + measItem = actionFormat1->measInfoList.list.array[elementIdx]; + switch(measItem->measType.present) + { + case MeasurementType_PR_NOTHING: + case MeasurementType_PR_measID: + break; + case MeasurementType_PR_measName: + { + RIC_FREE(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size) + break; + } + } + RIC_FREE(measItem, sizeof(MeasurementInfoItem_t)); + } + } + RIC_FREE(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size); + } + RIC_FREE(actionFormat1, sizeof(E2SM_KPM_ActionDefinition_Format1_t)); + } + break; + } + + case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2: + case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3: + case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4: + case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5: + case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_NOTHING: + break; } - return ROK; } /******************************************************************* * - * @brief Builds and Send the RicSubscriptionReq + * @brief Fill RIC Action Definition * * @details * - * Function : BuildAndSendRicSubscriptionReq + * Function : fillRicActionDef * - * Functionality:Fills the RicSubscriptionReq + * Functionality: Fill RIC Action Definition * - * @return ROK - success - * RFAILED - failure + * @params[in] RIC Action definition + * @return ROK + * RFAILED * - ******************************************************************/ - -uint8_t BuildAndSendRicSubscriptionReq(uint32_t duId) + * ****************************************************************/ +uint8_t fillRicActionDef(RICactionDefinition_t *ricActionDef) { + uint8_t ret = RFAILED; + asn_enc_rval_t encRetVal; + uint8_t elementCnt = 0, elementIdx = 0; + char *measurementTypeName[] = {"RRU.PrbTotDl", "RRU.PrbTotUl"}; + E2SM_KPM_ActionDefinition_t actionDef; + E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP; + MeasurementInfoItem_t *measItem = NULLP; + + while(true) + { + /* Fill E2SM-KPM Action Definition Format 1 */ - E2AP_PDU_t *e2apRicMsg = NULL; - RICsubscriptionRequest_t *ricSubscriptionReq; - uint8_t elementCnt; - uint8_t idx; - uint8_t ieId; - uint8_t ret; - asn_enc_rval_t encRetVal; /* Encoder return value */ - - DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n"); + /* RIC Stype Type */ + actionDef.ric_Style_Type = RIC_STYLE_TYPE; - RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t)); - if(e2apRicMsg == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); - return RFAILED; - } + /* RIC Action Definition Format 1 */ + actionDef.actionDefinition_formats.present = \ + E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1; - e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage; - RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); - if(e2apRicMsg->choice.initiatingMessage == NULLP) + RIC_ALLOC(actionDef.actionDefinition_formats.choice.actionDefinition_Format1, \ + sizeof(E2SM_KPM_ActionDefinition_Format1_t)); + if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1 == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1; + + /* Measurement Info List */ + elementCnt = 2; + actionFormat1->measInfoList.list.count = elementCnt; + actionFormat1->measInfoList.list.size = elementCnt * sizeof(MeasurementInfoItem_t *); + RIC_ALLOC(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size); + if(actionFormat1->measInfoList.list.array == NULL) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + for(elementIdx = 0; elementIdx < elementCnt; elementIdx++) + { + RIC_ALLOC(actionFormat1->measInfoList.list.array[elementIdx], sizeof(MeasurementInfoItem_t)); + if(actionFormat1->measInfoList.list.array[elementIdx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + measItem = actionFormat1->measInfoList.list.array[elementIdx]; + measItem->measType.present = MeasurementType_PR_measName; + + measItem->measType.choice.measName.size = strlen(measurementTypeName[elementIdx]); + RIC_ALLOC(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size); + if(measItem->measType.choice.measName.buf == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + memcpy(measItem->measType.choice.measName.buf, measurementTypeName[elementIdx], measItem->measType.choice.measName.size); + } + if(elementIdx < elementCnt) + break; + + /* Granularity Period */ + actionFormat1->granulPeriod = RIC_ACTION_GRANULARITY_PERIOD; /* In ms */ + + /* Prints the Msg formed */ + xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, &actionDef); + + /* Encode E2SM-KPM RIC Action Definition */ + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_E2SM_KPM_ActionDefinition, 0, &actionDef, PrepFinalEncBuf, encBuf); + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM action definition structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + + /* Copty encoded E2SM-KPM RIC action definition to E2AP octet string buffer */ + ricActionDef->size = encBufSize; + RIC_ALLOC(ricActionDef->buf, encBufSize); + if(ricActionDef->buf == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + memcpy(ricActionDef->buf, encBuf, encBufSize); + + ret = ROK; + break; + } + + FreeRicActionDefinition(actionDef); + return ret; +} + +/******************************************************************* + * + * @brief Fills RIC Action To Be Setup Item + * + * @details + * + * Function : fillActionToBeSetup + * + * Functionality: Fill the RIC Action To Be Setup Ite, + * RIC subscription DB + * + * @params[in] RICaction_ToBeSetup_ItemIEs_t *items + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscription *ricSubsDb) +{ + static uint8_t ricActionId = 0; + + if(actionItem == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); - RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t)); + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); return RFAILED; } - e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription; - e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; - e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest; - - RIC_ALLOC(ricSubscriptionReq, sizeof(RICsubscriptionRequest_t)); - ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest; - - elementCnt = 3; - ricSubscriptionReq->protocolIEs.list.count = elementCnt; - ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t); - - /* Initialize the subscription members */ - RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, \ - ricSubscriptionReq->protocolIEs.list.size); - if(ricSubscriptionReq->protocolIEs.list.array == NULLP) + + while(true) + { + actionItem->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item; + actionItem->criticality = CriticalityE2_ignore; + actionItem->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item; + + /* RIC Action ID */ + actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ++ricActionId; + ricSubsDb->actionSequence[ricActionId-1].id = \ + actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID; + + /* RIC Action Type */ + actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report; + + /* RIC Action Definition */ + RIC_ALLOC(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t)); + if(!actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + if(fillRicActionDef(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + ricSubsDb->numOfActions++; + return ROK; + } + + memset(&ricSubsDb->actionSequence[ricActionId-1], 0, sizeof(ActionInfo)); + return RFAILED; +} + +/******************************************************************* + * + * @brief Free Event Trigger Definition + * + * @details + * + * Function : FreeEventTriggerDef + * + * Functionality: Free Event Trigger Definition + * + * @params[in] E2SM-KPM Event Trigger Definition + * @return void + * + * ****************************************************************/ +void FreeEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef) +{ + if(eventTiggerDef) + { + switch(eventTiggerDef->eventDefinition_formats.present) + { + case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING: + break; + case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1: + RIC_FREE(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1, \ + sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t)); + break; + } + } +} + +/******************************************************************* + * + * @brief Fill Event Trigger Definition + * + * @details + * + * Function : fillEventTriggerDef + * + * Functionality: Fill Event Trigger Definition + * + * @params[in] RIC Event Trigger Definition + * @return ROK + * RFAILED + * + * ****************************************************************/ +uint8_t fillEventTriggerDef(RICeventTriggerDefinition_t *ricEventTriggerDef) +{ + uint8_t ret = RFAILED; + asn_enc_rval_t encRetVal; + E2SM_KPM_EventTriggerDefinition_t eventTiggerDef; + + while(true) + { + /* Fill E2SM-KPM Event Trigger Definition Format 1 */ + eventTiggerDef.eventDefinition_formats.present = \ + E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1; + + RIC_ALLOC(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1, \ + sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t)); + if(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1 == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod = 1000; /* In ms */ + + /* Prints the Msg formed */ + xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, &eventTiggerDef); + + /* Encode E2SM-KPM Event Trigger Definition */ + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_E2SM_KPM_EventTriggerDefinition, 0, &eventTiggerDef, PrepFinalEncBuf, encBuf); + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM event trigger definition structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + + /* Copy encoded E2SM-KPM event trigger definition to E2AP octet string buffer */ + ricEventTriggerDef->size = encBufSize; + RIC_ALLOC(ricEventTriggerDef->buf, encBufSize); + if(ricEventTriggerDef->buf == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + memcpy(ricEventTriggerDef->buf, encBuf, encBufSize); + + ret = ROK; + break; + } + + FreeEventTriggerDef(&eventTiggerDef); + return ret; +} + +/******************************************************************* + * + * @brief builds RIC Subscription Details + * + * @details + * + * Function : BuildsRicSubsDetails + * + * Functionality: Builds the RIC Subscription Details + * + * @params[in] RIC Subscription details to be filled + * RIC subscriotion DB + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails, RicSubscription *ricSubsDb) +{ + uint8_t elementCnt = 0; + uint8_t elementIdx = 0; + + if(subsDetails == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for RICSubscriptionRequestIEs failed"); - RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); - RIC_FREE(e2apRicMsg, (Size)sizeof(E2AP_PDU_t)); + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); return RFAILED; } - - for(idx=0; idxprotocolIEs.list.array[idx],\ - sizeof(RICsubscriptionRequest_IEs_t)); - if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP) + /* RIC Event Trigger Definition */ + if(fillEventTriggerDef(&subsDetails->ricEventTriggerDefinition) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + /* RIC Actions To Be Setup List */ + elementCnt = 1; + subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt; + subsDetails->ricAction_ToBeSetup_List.list.size = elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t *); + RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size); + if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed"); + break; + } + + for(elementIdx = 0; elementIdx < elementCnt; elementIdx++) { - for(ieId=0; ieIdricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t)); + if(!subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]) { - RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[ieId],\ - sizeof(RICsubscriptionRequest_IEs_t)); + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; } - RIC_FREE(ricSubscriptionReq->protocolIEs.list.array,\ - ricSubscriptionReq->protocolIEs.list.size); - RIC_FREE(e2apRicMsg->choice.initiatingMessage, \ - sizeof(InitiatingMessageE2_t)); - RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t)); - return RFAILED; } + if(elementIdx < elementCnt) + break; + + elementIdx = 0; + if(fillActionToBeSetup((RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], \ + ricSubsDb) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + return ROK; } + return RFAILED; +} - /* Filling RIC Request Id */ - idx = 0; - ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID; - ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\ - RICsubscriptionRequest_IEs__value_PR_RICrequestID; - - BuildRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID); +/******************************************************************* + * + * @brief Builds and Send the RicSubscriptionReq + * + * @details + * + * Function : BuildAndSendRicSubscriptionReq + * + * Functionality:Fills the RicSubscriptionReq + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) +{ + uint8_t ret = RFAILED; + E2AP_PDU_t *e2apRicMsg = NULL; + RICsubscriptionRequest_t *ricSubscriptionReq; + uint8_t elementCnt; + uint8_t idx; + asn_enc_rval_t encRetVal; /* Encoder return value */ + RanFunction *ranFuncDb = &duDb->ranFunction[0]; + + 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_RICsubscription; + e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; + e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest; + + ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest; + + elementCnt = 3; + ricSubscriptionReq->protocolIEs.list.count = elementCnt; + ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t); + + /* Initialize the subscription members */ + RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size); + if(ricSubscriptionReq->protocolIEs.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + break; + } + + for(idx=0; idxprotocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t)); + if(ricSubscriptionReq->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; + ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID; + ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\ + RICsubscriptionRequest_IEs__value_PR_RICrequestID; + if(BuildNewRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID, \ + &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription].requestId) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__); + break; + } + + + /* Filling RAN Function Id */ + idx++; + ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID; + ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\ + RICsubscriptionRequest_IEs__value_PR_RANfunctionID; + ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ranFuncDb->id; + + /* Filling RIC Subscription Details */ + idx++; + ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails; + ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\ + RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails; + if(BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails),\ + &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription]) != 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 RicSubscriptionRequest structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n"); + for(int i=0; i< encBufSize; i++) + { + DU_LOG("%x",encBuf[i]); + } + } - /* Filling RAN Function Id */ - idx++; - ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID; - ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\ - RICsubscriptionRequest_IEs__value_PR_RANfunctionID; - ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1; + /* Sending msg */ + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK) + { + DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed"); + break; + } + ranFuncDb->numOfSubscription++; + ret = ROK; + break; + } - /* Filling RIC Subscription Details */ - idx++; - ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails; - ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\ - RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails; + if(ret == RFAILED) + memset(&ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription], 0, sizeof(RicSubscription)); + FreeRicSubscriptionReq(e2apRicMsg); + return ret; +} + +/******************************************************************* + * + * @brief Process RicSubscriptionResponse + * + * @details + * + * Function : ProcRicSubscriptionRsp + * + * Functionality: Processes RicSubscriptionRsp + * + * @return ROK - void + * + ******************************************************************/ + +void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp) +{ + uint8_t duIdx = 0, ieIdx = 0,subsIdx = 0, notAdmitIdx = 0; + uint8_t ranFuncId = 0, actionId = 0; + DuDb *duDb = NULLP; + bool ricReqIdDecoded = false; + RicRequestId ricReqId; + RanFunction *ranFuncDb = NULLP; + RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP; + RICaction_NotAdmitted_List_t *notAdmitList = NULLP; + + DU_LOG("\nINFO --> E2AP : RIC Subscription Response received"); + + /* Fetch DU DB */ + SEARCH_DU_DB(duIdx, duId, duDb); + if(duDb == NULLP) + { + DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); + return; + } + + memset(&ricReqId, 0, sizeof(RicRequestId)); + if(ricSubscriptionRsp) + { + if(ricSubscriptionRsp->protocolIEs.list.array) + { + for(ieIdx=0; ieIdxprotocolIEs.list.count; ieIdx++) + { + if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]) + { + ricSubsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx]; + switch(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_RICrequestID: + { + ricReqId.requestorId = ricSubsRspIe->value.choice.RICrequestID.ricRequestorID; + ricReqId.instanceId = ricSubsRspIe->value.choice.RICrequestID.ricInstanceID; + ricReqIdDecoded = true; + break; + } + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsRspIe->value.choice.RANfunctionID; + if(duDb->ranFunction[ranFuncId-1].id == ranFuncId) + { + ranFuncDb = &duDb->ranFunction[ranFuncId-1]; + } + else + { + DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId); + return; + } + break; + } + case ProtocolIE_IDE2_id_RICactions_Admitted: + { + break; + } + case ProtocolIE_IDE2_id_RICactions_NotAdmitted: + { + if(!(ranFuncDb && ricReqIdDecoded)) + return; + + notAdmitList = &ricSubsRspIe->value.choice.RICaction_NotAdmitted_List; + for(notAdmitIdx = 0; notAdmitIdx < notAdmitList->list.count; notAdmitIdx++) + { + actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\ + value.choice.RICaction_NotAdmitted_Item.ricActionID; + + /* Remove action from RAN Function's subscription list */ + for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++) + { + if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) && + (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId)) + { + if(ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId-1].id == actionId) + { + memset(&ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId-1], 0, \ + sizeof(ActionInfo)); + ranFuncDb->subscriptionList[subsIdx].numOfActions--; + break; + } + } + } + } + break; + } + } + } + } + } + } +} + +/******************************************************************* + * + * @brief deallocate the memory allocated in E2SetupFailure + * + * @details + * + * Function : FreeE2SetupFailure + * + * Functionality: deallocate the memory allocated in E2SetupFailure + * + * @params[in] E2AP_PDU_t *e2apMsg + * + * @return void + * ****************************************************************/ +void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg) +{ + uint8_t arrIdx = 0; + E2setupFailure_t *e2SetupFail; + + if(e2apMsg) + { + if(e2apMsg->choice.unsuccessfulOutcome) + { + e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure; + if(e2SetupFail->protocolIEs.list.array) + { + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + { + RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t)); + } + RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size); + } + RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t)); + } + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* + * + * @brief Buld and send the E2 Setup failure + * + * @details + * + * Function : BuildAndSendE2SetupFailure + * + * Functionality: + * - Buld and send the E2 Setup failure + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId) +{ + E2AP_PDU_t *e2apMsg = NULL; + E2setupFailure_t *e2SetupFailure; + asn_enc_rval_t encRetVal; + uint8_t arrIdx; + uint8_t elementCnt; + bool memAllocFailed = false; + + DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n"); + while(true) + { + RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); + if(e2apMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + break; + } + e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome; + RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2)); + if(e2apMsg->choice.unsuccessfulOutcome == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + break; + } + + e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup; + e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject; + e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure; + e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure; + + elementCnt = 3; + e2SetupFailure->protocolIEs.list.count = elementCnt; + e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *); + + RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size); + if(e2SetupFailure->protocolIEs.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed"); + break; + } + + for(arrIdx=0; arrIdxprotocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs)); + if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed"); + memAllocFailed = true; + break; + } + } + + if(memAllocFailed == true) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed"); + break; + } + + /* Trans Id */ + arrIdx = 0; + e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; + e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID; + e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId; + + arrIdx++; + e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2; + e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2; + e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol; + e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified; + + arrIdx++; + e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2; + e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore; + e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2; + e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s; + + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf); + + /* Check encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup 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 Setup Failure\n"); + for(int i=0; i< encBufSize; i++) + { + DU_LOG("%x",encBuf[i]); + } + } + + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) + { + DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed"); + break; + } + break; + } + + FreeE2SetupFailure(e2apMsg); +} + +/******************************************************************* + * + * @brief process the e2setup request + * + * @details + * + * Function : ProcE2SetupReq + * + * Functionality: process the e2setup request + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq) +{ + uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0, transId =0, ranFuncIdx; + DuDb *duDb = NULLP; + E2nodeComponentConfigAddition_List_t *e2NodeAddList; + E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem; + RANfunction_ItemIEs_t *ranFuncItemIe; + RANfunction_Item_t *ranFunItem; + RANfunctions_List_t *ranFunctionsList; + + if(e2SetupReq) + { + if(e2SetupReq->protocolIEs.list.array) + { + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + { + if(e2SetupReq->protocolIEs.list.array[arrIdx]) + { + switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id) + { + case ProtocolIE_IDE2_id_TransactionID: + { + transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID; + break; + } + case ProtocolIE_IDE2_id_GlobalE2node_ID: + { + if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID) + { + *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0]; + + SEARCH_DU_DB(duIdx, *duId, duDb); + if(duDb == NULLP) + { + duDb = &ricCb.duInfo[ricCb.numDu]; + ricCb.numDu++; + } + memset(duDb, 0, sizeof(DuDb)); + duDb->duId = *duId; + } + break; + } + case ProtocolIE_IDE2_id_RANfunctionsAdded: + { + ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List; + + if(ranFunctionsList->list.array) + { + for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) + { + ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx]; + ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item; + duDb->ranFunction[ranFunItem->ranFunctionID-1].id = ranFunItem->ranFunctionID; + duDb->ranFunction[ranFunItem->ranFunctionID-1].revisionCounter = ranFunItem->ranFunctionRevision; + duDb->numOfRanFunction++; + } + } + break; + } + case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition: + { + e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List; + if(e2NodeAddList->list.array) + { + for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++) + { + if(e2NodeAddList->list.array[e2NodeAddListIdx]) + { + e2NodeAddItem = \ + (E2nodeComponentConfigAddition_ItemIEs_t *)e2NodeAddList->list.array[e2NodeAddListIdx]; + if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\ + choice.e2nodeComponentInterfaceTypeF1) + { + duDb->e2NodeComponent.interfaceType = F1; + duDb->e2NodeComponent.componentId = \ + e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\ + choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0]; + } + } + } + } + break; + } + default: + break; + } + } + } + } + } + + if(BuildAndSendE2SetupRsp(duDb, transId) !=ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response"); + return RFAILED; + } + return ROK; +} +/******************************************************************* + * + * @brief Deallocate the memory allocated for E2 Reset Response + * + * @details + * + * Function : FreeE2ResetResponse + * + * Functionality: + * - freeing the memory allocated for E2ResetResponse + * + * @params[in] E2AP_PDU_t *e2apMsg + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg) +{ + uint8_t ieIdx =0; + ResetResponseE2_t *resetResponse; + + if(e2apMsg != NULLP) + { + if(e2apMsg->choice.successfulOutcome != NULLP) + { + resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2; + if(resetResponse->protocolIEs.list.array) + { + for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++) + { + if(resetResponse->protocolIEs.list.array[ieIdx]) + { + RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t)); + } + } + RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size); + } + RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); + } + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* + * + * @brief Buld and send the E2 Reset Response msg + * + * @details + * + * Function : BuildAndSendE2ResetResponse + * + * Functionality: + * - Buld and send the E2 Reset Response Message + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId) +{ + uint8_t ieIdx = 0, elementCnt = 0; + uint8_t ret = RFAILED; + E2AP_PDU_t *e2apMsg = NULLP; + ResetResponseE2_t *resetResponse; + asn_enc_rval_t encRetVal; /* Encoder return value */ + + DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n"); + do + { + RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); + if(e2apMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed"); + break; + } + e2apMsg->present = E2AP_PDU_PR_successfulOutcome; + + RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); + if(e2apMsg->choice.successfulOutcome == NULLP) + { + DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome"); + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + return RFAILED; + } + + e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset; + e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject; + e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2; + resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2; + + elementCnt = 1; + resetResponse->protocolIEs.list.count = elementCnt; + resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *); + RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size); + if(!resetResponse->protocolIEs.list.array) + { + DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array"); + break; + } + + for(ieIdx=0; ieIdx < elementCnt; ieIdx++) + { + RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t)); + if(!resetResponse->protocolIEs.list.array[ieIdx]) + { + DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element"); + break; + } + } + if(ieIdx < elementCnt) + break; + + ieIdx = 0; + resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID; + resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject; + resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID; + resetResponse->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 reset response structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + return RFAILED; + } + else + { + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset 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 Reset Response"); + return RFAILED; + } + + ret = ROK; + break; + }while(true); + + FreeE2ResetResponse(e2apMsg); + return ROK; +} + +/******************************************************************* + * + * @brief process the E2 Reset Request + * + * @details + * + * Function : ProcE2ResetReq + * + * Functionality: Process E2 Reset Request + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t ProcE2ResetReq(uint32_t duId, ResetRequestE2_t *resetReq) +{ + uint8_t ieIdx = 0, duIdx = 0; + uint8_t transId = 0, cause = 0; + DuDb *duDb = NULLP; + + if(resetReq) + { + if(resetReq->protocolIEs.list.array) + { + for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++) + { + if(resetReq->protocolIEs.list.array[ieIdx]) + { + switch(resetReq->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_TransactionID: + transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID; + break; + case ProtocolIE_IDE2_id_CauseE2: + DU_LOG("\nDEBUG --> E2AP : Reset reason %d", resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present); + switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present) + { + case CauseE2_PR_NOTHING: + break; + case CauseE2_PR_ricRequest: + cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest; + break; + case CauseE2_PR_ricService: + cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService; + break; + case CauseE2_PR_e2Node: + cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node; + break; + case CauseE2_PR_transport: + cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport; + break; + case CauseE2_PR_protocol: + cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol; + break; + case CauseE2_PR_misc: + cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc; + break; + } + DU_LOG("\nDEBUG --> E2AP : Reset cause %d", cause); + break; + } + } + } + } + } + BuildAndSendResetResponse(duId, transId); + return ROK; +} + +/******************************************************************* + * + * @brief deallocate the memory allocated in building the + * Service Query message + * + * @details + * + * Function : FreeRicServiceQuery + * + * Functionality: deallocate the memory allocated in building + * Ric Service Query message + * + * @params[in] E2AP_PDU_t *e2apMsg + * + * @return void + * ****************************************************************/ + +void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg) +{ + uint8_t arrIdx = 0, ranFuncIdx=0; + RANfunctionsID_List_t *ranFuncAcceptedList=NULL; + RICserviceQuery_t *ricServiceQuery=NULL; + + if(e2apMsg) + { + if(e2apMsg->choice.initiatingMessage) + { + ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery; + if(ricServiceQuery->protocolIEs.list.array) + { + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + { + if(ricServiceQuery->protocolIEs.list.array[arrIdx]) + { + switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id) + { + case ProtocolIE_IDE2_id_RANfunctionsAccepted: + { + ranFuncAcceptedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List; + if(ranFuncAcceptedList->list.array) + { + for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) + { + RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t)); + } + RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size); + } + break; + } + case RICserviceQuery_IEs__value_PR_TransactionID: + { + break; + } + } + RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t)); + } + } + RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size); + } + RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + } + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* + * + * @brief build and send the ric service Query + * + * @details + * + * Function : BuildAndSendRicServiceQuery + * + * Functionality: build and send the ric service Query + * @return ROK - success + * RFAILED - Acknowledge + * + ******************************************************************/ + +uint8_t BuildAndSendRicServiceQuery(DuDb *duDb) +{ + uint8_t arrIdx; + uint8_t elementCnt; + uint8_t ret = RFAILED; + bool memAllocFailed = false; + E2AP_PDU_t *e2apMsg = NULL; + asn_enc_rval_t encRetVal; + RICserviceQuery_t *ricServiceQuery; + + DU_LOG("\nINFO --> E2AP : Building Ric service Query\n"); + while(true) + { + RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); + if(e2apMsg == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + break; + } + e2apMsg->present = E2AP_PDU_PR_initiatingMessage; + RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2)); + if(e2apMsg->choice.initiatingMessage == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + break; + } - BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails)); + e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery; + e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; + e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery; + ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery; + elementCnt = 1; + /* Fill Accepted RAN function IE If Ran function information is stored in databse */ + if(duDb->numOfRanFunction) + elementCnt++; - /* Prints the Msg formed */ - xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg); + ricServiceQuery->protocolIEs.list.count = elementCnt; + ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*); - 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 RicSubscriptionRequest structure (at %s)\n",\ - encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); - return RFAILED; - } - else - { - DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n"); - for(int i=0; i< encBufSize; i++) + RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size); + if(ricServiceQuery->protocolIEs.list.array == NULLP) { - DU_LOG("%x",encBuf[i]); - } - } - - - /* Sending msg */ - if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) - { - DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed"); - return RFAILED; - } + DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed"); + break; + } - return ROK; -} + for(arrIdx=0; arrIdxprotocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t)); + if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed"); + memAllocFailed = true; + break; + } + } + if(memAllocFailed == true) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed"); + break; + } -/******************************************************************* - * - * @brief Process RicSubscriptionResponse - * - * @details - * - * Function : ProcRicSubscriptionRsp - * - * Functionality: Processes RicSubscriptionRsp - * - * @return ROK - void - * - ******************************************************************/ + /* Trans Id */ + arrIdx = 0; + ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; + ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID; + ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb); + + if(duDb->numOfRanFunction) + { + /* Accepted RAN function Id */ + arrIdx++; + ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted; + ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List; + if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to build Ran function added 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); -void ProcRicSubscriptionResponse(uint32_t duId) -{ - uint8_t duIdx = 0; - DuDb *duDb; + /* Check encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n"); + for(int i=0; i< encBufSize; i++) + { + DU_LOG("%x",encBuf[i]); + } + } - DU_LOG("\nINFO --> E2AP : RICsubscriptionResponse Msg Acknowledged"); + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK) + { + DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed"); + break; + } - SEARCH_DU_DB(duIdx, duId, duDb); - if(duDb) - duDb->ricSubscribedToDu = true; + ret =ROK; + break; + } + FreeRicServiceQuery(e2apMsg); + return ret; } /******************************************************************* * - * @brief deallocate the memory allocated in E2SetupFailure + * @brief deallocate the memory allocated in RicServiceUpdateFailure * * @details * - * Function : FreeE2SetupFailure + * Function : FreeRicServiceUpdateFailure * - * Functionality: deallocate the memory allocated in E2SetupFailure + * Functionality: deallocate the memory allocated in RicServiceUpdatefailure * * @params[in] E2AP_PDU_t *e2apMsg * * @return void * ****************************************************************/ -void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg) + +void FreeRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg) { uint8_t arrIdx = 0; - E2setupFailure_t *e2SetupFail; - + RICserviceUpdateFailure_t *ricServiceUpdateFailure=NULL; + if(e2apMsg) { if(e2apMsg->choice.unsuccessfulOutcome) { - e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure; - if(e2SetupFail->protocolIEs.list.array) + ricServiceUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure; + if(ricServiceUpdateFailure->protocolIEs.list.array) { - for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) { - RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t)); + RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t)); } - RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size); + RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array, ricServiceUpdateFailure->protocolIEs.list.size); } RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t)); } @@ -892,29 +2298,73 @@ void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg) /******************************************************************* * - * @brief Buld and send the E2 Setup failure + * @brief fill E2 failure cause * * @details * - * Function : BuildAndSendE2SetupFailure + * Function : fillE2FailureCause * - * Functionality: - * - Buld and send the E2 Setup failure + * Functionality: fill E2 failure cause * @return ROK - success * RFAILED - failure * - * ****************************************************************/ + ******************************************************************/ -uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId) +void fillE2FailureCause(CauseE2_t *cause, CauseE2_PR causePresent, uint8_t reason) { + cause->present = causePresent; + + switch(cause->present) + { + case CauseE2_PR_ricRequest: + cause->choice.ricRequest = reason; + break; + case CauseE2_PR_ricService: + cause->choice.ricService = reason; + break; + case CauseE2_PR_e2Node: + cause->choice.e2Node = reason; + break; + case CauseE2_PR_transport: + cause->choice.transport = reason; + break; + case CauseE2_PR_protocol: + cause->choice.protocol = reason; + break; + case CauseE2_PR_misc: + cause->choice.misc = reason; + break; + default: + cause->choice.misc = CauseE2Misc_unspecified; + break; + } +} + +/******************************************************************* + * + * @brief build and send the ric service update failure + * + * @details + * + * Function : BuildAndSendRicServiceUpdateFailure + * + * Functionality: build and send the ric service update failure + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t BuildAndSendRicServiceUpdateFailure(uint32_t duId, int8_t transId, CauseE2_PR causePresent, uint8_t reason) +{ + E2AP_PDU_t *e2apMsg = NULL; - E2setupFailure_t *e2SetupFailure; asn_enc_rval_t encRetVal; - uint8_t arrIdx; - uint8_t elementCnt; - bool memAllocFailed = false; + uint8_t ret = RFAILED; + uint8_t arrIdx=0; + uint8_t elementCnt=0; + RICserviceUpdateFailure_t *ricServiceFailure=NULL; - DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n"); + DU_LOG("\nINFO --> E2AP : Building Ric service update failure\n"); while(true) { RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); @@ -931,58 +2381,55 @@ uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId) break; } - e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup; + e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate; e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject; - e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure; - e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure; + e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure; + ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure; elementCnt = 3; - e2SetupFailure->protocolIEs.list.count = elementCnt; - e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *); + ricServiceFailure->protocolIEs.list.count = elementCnt; + ricServiceFailure->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateFailure_IEs_t *); - RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size); - if(e2SetupFailure->protocolIEs.list.array == NULLP) + RIC_ALLOC(ricServiceFailure->protocolIEs.list.array, ricServiceFailure->protocolIEs.list.size); + if(ricServiceFailure->protocolIEs.list.array == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed"); + DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed"); break; } for(arrIdx=0; arrIdxprotocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs)); - if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP) + RIC_ALLOC(ricServiceFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t)); + if(ricServiceFailure->protocolIEs.list.array[arrIdx] == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed"); - memAllocFailed = true; + DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed"); break; } } - - if(memAllocFailed == true) + if(arrIdx E2AP : Memory allocation for E2FailureIEs failed"); - break; + DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed"); + break; } /* Trans Id */ arrIdx = 0; - e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; - e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; - e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID; - e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId; + ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; + ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TransactionID; + ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId; arrIdx++; - e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2; - e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; - e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2; - e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol; - e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified; + ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2; + ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_CauseE2; + fillE2FailureCause(&ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, causePresent, reason); arrIdx++; - e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2; - e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore; - e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2; - e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s; + ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2; + ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore; + ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TimeToWaitE2; + ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s; xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); memset(encBuf, 0, ENC_BUF_MAX_LEN); @@ -992,13 +2439,13 @@ uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId) /* Check encode results */ if(encRetVal.encoded == ENCODE_FAIL) { - DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\ + DU_LOG("\nERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); break; } else { - DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n"); + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n"); for(int i=0; i< encBufSize; i++) { DU_LOG("%x",encBuf[i]); @@ -1007,192 +2454,168 @@ uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId) if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) { - DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed"); + DU_LOG("\nERROR --> E2AP : Sending RIC service update failed"); break; } + ret = ROK; break; } - FreeE2SetupFailure(e2apMsg); + FreeRicServiceUpdateFailure(e2apMsg); + return ret; } + /******************************************************************* * - * @brief process the e2setup request + * @brief deallocate the memory allocated in RicServiceUpdateAck( * * @details * - * Function : ProcE2SetupReq + * Function : FreeRicServiceUpdateAck * - * Functionality: process the e2setup request + * Functionality: deallocate the memory allocated in RicServiceUpdateAck * - * @return ROK - success - * RFAILED - failure + * @params[in] E2AP_PDU_t *e2apMsg * - ******************************************************************/ + * @return void + * ****************************************************************/ -uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq) +void FreeRicServiceUpdateAck(E2AP_PDU_t *e2apMsg) { - uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0, transId =0, ranFuncIdx; - DuDb *duDb = NULLP; - E2nodeComponentConfigAddition_List_t *e2NodeAddList; - E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem; - RANfunction_ItemIEs_t *ranFuncItemIe; - RANfunction_Item_t *ranFunItem; - RANfunctions_List_t *ranFunctionsList; + uint8_t arrIdx = 0, ranFuncIdx=0; + RANfunctionsID_List_t *acceptedList=NULL; + RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL; + RANfunctionsIDcause_List_t *rejectedList=NULL; - if(e2SetupReq) + if(e2apMsg) { - if(e2SetupReq->protocolIEs.list.array) + if(e2apMsg->choice.successfulOutcome) { - for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge; + if(ricServiceUpdateAck->protocolIEs.list.array) { - if(e2SetupReq->protocolIEs.list.array[arrIdx]) + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) { - switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id) + if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx]) { - case ProtocolIE_IDE2_id_TransactionID: - { - transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID; - break; - } - case ProtocolIE_IDE2_id_GlobalE2node_ID: - { - if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID) - { - *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0]; - - SEARCH_DU_DB(duIdx, *duId, duDb); - if(duDb == NULLP) - { - duDb = &ricCb.duInfo[ricCb.numDu]; - ricCb.numDu++; - } - memset(duDb, 0, sizeof(DuDb)); - duDb->duId = *duId; - } - break; - } - case ProtocolIE_IDE2_id_RANfunctionsAdded: - { - - ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List; - - if(ranFunctionsList->list.array) - { - for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) - { - ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx]; - ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item; - duDb->ranFunction[ranFunItem->ranFunctionID-1].id = ranFunItem->ranFunctionID; - duDb->ranFunction[ranFunItem->ranFunctionID-1].revisionCounter = ranFunItem->ranFunctionRevision; - duDb->numOfRanFunction++; + switch(ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id) + { + case ProtocolIE_IDE2_id_RANfunctionsAccepted: + { + acceptedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List; + if(acceptedList->list.array) + { + for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) + { + RIC_FREE(acceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t)); + } + RIC_FREE(acceptedList->list.array, acceptedList->list.size); } + break; } - break; - } - case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition: - { - e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List; - if(e2NodeAddList->list.array) + + case ProtocolIE_IDE2_id_RANfunctionsRejected: { - for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++) + rejectedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List; + if(rejectedList->list.array) { - if(e2NodeAddList->list.array[e2NodeAddListIdx]) + for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) { - e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx]; - if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\ - e2nodeComponentInterfaceTypeF1) - { - duDb->e2NodeComponent.interfaceType = F1; - duDb->e2NodeComponent.componentId = e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0]; - } + RIC_FREE(rejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t)); } + RIC_FREE(rejectedList->list.array, rejectedList->list.size); } + break; } - break; - } - default: - break; } + RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t)); } } - } - } - - if(BuildAndSendE2SetupRsp(duDb, transId) !=ROK) - { - DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response"); - return RFAILED; + RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size); + } + RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); + } + RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); } - return ROK; } /******************************************************************* * - * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg + * @brief Build RAN function rejected list * * @details * - * Function : FreeE2NodeConfigUpdate + * Function : BuildRanFunctionRejectedList * - * Functionality: - * - freeing the memory allocated for E2nodeConfigurationUpdate + * Functionality: Build RAN function rejected list * - * @params[in] E2AP_PDU_t *e2apMsg - * @return ROK - success - * RFAILED - failure + * @params[in] + * Count of ran functions to be rejected in the list + * Received list of RAN functions * + * @return ROK - success + * RFAILED - failure * ****************************************************************/ -void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg) -{ - uint8_t arrIdx =0; - E2nodeConfigurationUpdate_t *e2NodeConfigUpdateAck; - if(e2apMsg != NULLP) +uint8_t BuildRanFunctionRejectedList(uint8_t count, RanFunction *ranFunRejectedList, RANfunctionsIDcause_List_t *ranFuncRejectedList) +{ + uint8_t ranFuncIdx = 0; + RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL; + + ranFuncRejectedList->list.count = count; + + ranFuncRejectedList->list.size = ranFuncRejectedList->list.count*sizeof(RANfunctionIDcause_ItemIEs_t*); + RIC_ALLOC(ranFuncRejectedList->list.array, ranFuncRejectedList->list.size); + if(ranFuncRejectedList->list.array == NULLP) { - if(e2apMsg->choice.successfulOutcome != NULLP) + DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array"); + return RFAILED; + } + + for(ranFuncIdx = 0; ranFuncIdx< ranFuncRejectedList->list.count; ranFuncIdx++) + { + RIC_ALLOC(ranFuncRejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t)); + if(ranFuncRejectedList->list.array[ranFuncIdx] == NULLP) { - e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge; - if(e2NodeConfigUpdateAck->protocolIEs.list.array != NULLP) - { - for(arrIdx = 0; arrIdx < e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++) - { - RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_t)); - } - RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size); - } - RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); + DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array item"); + return RFAILED; } - RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[ranFuncIdx]; + ranFuncRejectedItemIe->id = ProtocolIE_IDE2_id_RANfunctionIEcause_Item; + ranFuncRejectedItemIe->criticality= CriticalityE2_ignore; + ranFuncRejectedItemIe->value.present = RANfunctionIDcause_ItemIEs__value_PR_RANfunctionIDcause_Item; + ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID = ranFunRejectedList[ranFuncIdx].id; + fillE2FailureCause(&ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.cause, CauseE2_PR_ricService,\ + CauseE2RICservice_ran_function_not_supported); } + + return ROK; } /******************************************************************* * - * @brief Buld and send the E2 node config update msg + * @brief build and send the ric service update Acknowledge * * @details * - * Function : BuildAndSendE2NodeConfigUpdate + * Function : BuildAndSendRicServiceUpdateAcknowledge * - * Functionality: - * - Buld and send the E2 node config update msg + * Functionality: build and send the ric service update Acknowledge * @return ROK - success - * RFAILED - failure + * RFAILED - Acknowledge * - * ****************************************************************/ + ******************************************************************/ -uint8_t BuildAndSendE2NodeConfigUpdateAck(uint32_t duId) +uint8_t BuildAndSendRicServiceUpdateAcknowledge(DuDb *duDb, int8_t transId, RicTmpRanFunList ricRanFuncList) { - uint8_t arrIdx = 0,elementCnt = 1; - uint8_t ret = ROK; - E2AP_PDU_t *e2apMsg = NULLP; - E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP; - asn_enc_rval_t encRetVal; /* Encoder return value */ + E2AP_PDU_t *e2apMsg = NULL; + asn_enc_rval_t encRetVal; + uint8_t arrIdx=0, elementCnt=0, ret=RFAILED;; + RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL; - DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n"); - do + DU_LOG("\nINFO --> E2AP : Building Ric service update Acknowledge\n"); + while(true) { RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); if(e2apMsg == NULLP) @@ -1200,366 +2623,432 @@ uint8_t BuildAndSendE2NodeConfigUpdateAck(uint32_t duId) DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); break; } - e2apMsg->present = E2AP_PDU_PR_successfulOutcome; - RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); + e2apMsg->present = E2AP_PDU_PR_successfulOutcome; + RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(struct SuccessfulOutcomeE2)); if(e2apMsg->choice.successfulOutcome == NULLP) { DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); - RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); - return RFAILED; + break; } - + + e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate; e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject; - e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate; - e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge; - e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge; + e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge; + ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge; + + elementCnt = 1; + if(ricRanFuncList.numOfRanFunAccepted) + elementCnt++; + if(ricRanFuncList.numOfRanFuneRejected) + elementCnt++; + - e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt; - e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*); - /* Initialize the Ric Indication members */ - RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, \ - e2NodeConfigUpdateAck->protocolIEs.list.size); - if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP) + ricServiceUpdateAck->protocolIEs.list.count = elementCnt; + ricServiceUpdateAck->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateAcknowledge_IEs_t*); + + RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size); + if(ricServiceUpdateAck->protocolIEs.list.array == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed"); + DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed"); break; } - - for(arrIdx =0; arrIdxprotocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t)); - if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP) + RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t)); + if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx] == NULLP) { - - DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed"); + DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed"); break; } } + if(arrIdx E2AP : Memory allocation for ricServiceUpdateAckIEs failed"); + break; + } + /* Trans Id */ arrIdx = 0; - /* TransactionID */ - e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; - e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; - e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID; - e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID; - + ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; + ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_TransactionID; + ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId; + if(ricRanFuncList.numOfRanFunAccepted) + { + /* Accepted RAN function List */ + arrIdx++; + ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted; + ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsID_List; + if(BuildRanFunctionAcceptedList(duDb, ricRanFuncList.numOfRanFunAccepted, ricRanFuncList.ranFunAcceptedList,\ + &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceUpdate)!=ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list"); + break; + } + } + + if(ricRanFuncList.numOfRanFuneRejected) + { + /* RAN Functions Rejected List */ + arrIdx++; + ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsRejected; + ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsIDcause_List; + if(BuildRanFunctionRejectedList(ricRanFuncList.numOfRanFuneRejected, ricRanFuncList.ranFunRejectedList, \ + &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List)!=ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to build Ran function rejected 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); + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf); + + /* Check encode results */ if(encRetVal.encoded == ENCODE_FAIL) { - DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\ + DU_LOG("\nERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); - return RFAILED; + break; } else { - DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n"); + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\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) + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK) { - DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack "); - return RFAILED; + DU_LOG("\nERROR --> E2AP : Sending RIC service update ack failed"); + break; } - + ret =ROK; break; - }while(true); - - FreeE2NodeConfigUpdateAck(e2apMsg); - return ret; + } + FreeRicServiceUpdateAck(e2apMsg); + return ret; } /******************************************************************* * - * @brief Deallocate the memory allocated for E2 Reset Response + * @brief process the RIC service update * * @details * - * Function : FreeE2ResetResponse + * Function : ProcRicserviceUpdate * - * Functionality: - * - freeing the memory allocated for E2ResetResponse + * Functionality: process the RIC service update * - * @params[in] E2AP_PDU_t *e2apMsg * @return ROK - success * RFAILED - failure * - * ****************************************************************/ -void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg) + ******************************************************************/ + +void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate) { - uint8_t ieIdx =0; - ResetResponseE2_t *resetResponse; + RicTmpRanFunList ricRanFuncList; + DuDb *duDb = NULLP; + int8_t transId =-1; + uint8_t duIdx = 0, elementCnt =0, arrIdx = 0; + uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0; + RANfunction_ItemIEs_t *ranFuncItemIe =NULL; + RANfunction_Item_t *ranFuncItem =NULL; + RANfunctionID_Item_t *ranFuncIdItem=NULL; + RANfunctions_List_t *ranFuncList=NULL; + RANfunctionsID_List_t *deleteList=NULL; + RANfunctionID_ItemIEs_t *delRanFuncItem=NULL; + + SEARCH_DU_DB(duIdx, duId, duDb); + if(duDb == NULLP) + { + DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); + return; + } + memset(&ricRanFuncList, 0, sizeof(RicTmpRanFunList)); - if(e2apMsg != NULLP) + if(!ricServiceUpdate) { - if(e2apMsg->choice.successfulOutcome != NULLP) + DU_LOG("\nERROR --> E2AP : ricServiceUpdate pointer is null"); + return; + } + + if(!ricServiceUpdate->protocolIEs.list.array) + { + DU_LOG("\nERROR --> E2AP : ricServiceUpdate array pointer is null"); + return; + } + elementCnt = ricServiceUpdate->protocolIEs.list.count; + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + { + if(!ricServiceUpdate->protocolIEs.list.array[arrIdx]) { - resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2; - if(resetResponse->protocolIEs.list.array) - { - for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++) + DU_LOG("\nERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx); + return; + } + + switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id) + { + case ProtocolIE_IDE2_id_TransactionID: { - if(resetResponse->protocolIEs.list.array[ieIdx]) + transId = ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID; + + if(transId < 0 || transId > 255) { - RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t)); + DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId); + return; } + break; } - RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size); - } - RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); - } - RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); - } -} -/******************************************************************* - * - * @brief Buld and send the E2 Reset Response msg - * - * @details - * - * Function : BuildAndSendE2ResetResponse - * - * Functionality: - * - Buld and send the E2 Reset Response Message - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId) -{ - uint8_t ieIdx = 0, elementCnt = 0; - uint8_t ret = RFAILED; - E2AP_PDU_t *e2apMsg = NULLP; - ResetResponseE2_t *resetResponse; - asn_enc_rval_t encRetVal; /* Encoder return value */ + case ProtocolIE_IDE2_id_RANfunctionsAdded: + { + ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List; - DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n"); - do - { - RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); - if(e2apMsg == NULLP) - { - DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed"); - break; - } - e2apMsg->present = E2AP_PDU_PR_successfulOutcome; + if(ranFuncList->list.array) + { + for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) + { + ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx]; + ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item; - RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); - if(e2apMsg->choice.successfulOutcome == NULLP) - { - DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome"); - RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t)); - return RFAILED; - } - - e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset; - e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject; - e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2; - resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2; + /* Adding the ran function in temporary list */ + ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID; + ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision; + ricRanFuncList.numOfRanFunAccepted++; - elementCnt = 1; - resetResponse->protocolIEs.list.count = elementCnt; - resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *); - RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size); - if(!resetResponse->protocolIEs.list.array) - { - DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array"); - break; - } + /* Adding the new ran function in DB*/ + duDb->ranFunction[ranFuncItem->ranFunctionID-1].id = ranFuncItem->ranFunctionID; + duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision; + duDb->numOfRanFunction++; - for(ieIdx=0; ieIdx < elementCnt; ieIdx++) - { - RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t)); - if(!resetResponse->protocolIEs.list.array[ieIdx]) - { - DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element"); - break; - } - } - if(ieIdx < elementCnt) - break; + /* Calculating total number of ran fuctions which are received for addition */ + recvdRanFuncCount++; + } + } + break; + } + + case ProtocolIE_IDE2_id_RANfunctionsModified: + { + + ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List; + if(ranFuncList->list.array) + { + for(ranFuncIdx = 0; ranFuncIdx< ranFuncList->list.count; ranFuncIdx++) + { + ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx]; + ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item; + if(duDb->ranFunction[ranFuncItem->ranFunctionID-1].id != ranFuncItem->ranFunctionID) + { + /* Calculating total number of ran fuctions which are not present */ + failedRanFuncCount++; + + /* Adding the ran function in temporary list */ + ricRanFuncList.ranFunRejectedList[ricRanFuncList.numOfRanFuneRejected].id = ranFuncItem->ranFunctionID; + ricRanFuncList.numOfRanFuneRejected++; + } + else + { + + /* Adding the ran function in temporary list */ + ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID; + ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision; + ricRanFuncList.numOfRanFunAccepted++; + + /* Updating the new ran function in DB*/ + duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision; + } + /* Calculating total number of ran fuctions which are received for modification */ + recvdRanFuncCount++; + } + } + break; + } + case ProtocolIE_IDE2_id_RANfunctionsDeleted: + { - ieIdx = 0; - resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID; - resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject; - resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID; - resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId; + deleteList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List; + if(deleteList->list.array) + { + for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++) + { + delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx]; + ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item; + if(duDb->ranFunction[ranFuncIdItem->ranFunctionID-1].id == ranFuncIdItem->ranFunctionID) + { + memset(&duDb->ranFunction[ranFuncIdItem->ranFunctionID-1], 0, sizeof(RanFunction)); + duDb->numOfRanFunction--; + } - xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); + /* Calculating total number of ran fuctions which are received for deletion */ + recvdRanFuncCount++; + } + } + break; + } - 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 reset response structure (at %s)\n",\ - encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); - return RFAILED; + default: + { + DU_LOG("\nERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id); + break; + } } - else + } + + /* Sending RIC Service Update Failed if all RAN Functions received fail or if any IE processing fails + * Else sending RIC Service Update Acknowledge */ + if((elementCnt > arrIdx) ||((recvdRanFuncCount > 0) && (recvdRanFuncCount == failedRanFuncCount))) + { + if(BuildAndSendRicServiceUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK) { - DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n"); - for(int i=0; i< encBufSize; i++) - { - DU_LOG("%x",encBuf[i]); - } + DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update Failure"); + return; } - - /* Sending msg */ - if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) + } + else + { + if(BuildAndSendRicServiceUpdateAcknowledge(duDb, transId, ricRanFuncList) != ROK) { - DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response"); - return RFAILED; + DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update acknowledge"); + return; } - - ret = ROK; - break; - }while(true); - - FreeE2ResetResponse(e2apMsg); - return ROK; + } } /******************************************************************* * - * @brief process the E2 Reset Request + * @brief Processing RIC subscription failure from DU * * @details * - * Function : ProcE2ResetReq + * Function : ProcRicSubscriptionFailure * - * Functionality: Process E2 Reset Request + * Functionality: Processing RIC subscription failure from DU * + * @param ID of DU from which message was sent + * RIC Subscription failure message * @return ROK - success * RFAILED - failure * ******************************************************************/ - -uint8_t ProcE2ResetReq(uint32_t duId, ResetRequestE2_t *resetReq) +uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricSubscriptionFailure) { - uint8_t ieIdx = 0, duIdx = 0; - uint8_t transId = 0, cause = 0; + uint8_t ieIdx = 0, duIdx = 0, subsIdx = 0; + uint8_t ranFuncId = 0; + bool ricReqIdDecoded = false; DuDb *duDb = NULLP; + RanFunction *ranFuncDb = NULLP; + RicRequestId ricReqId; + RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP; - if(resetReq) + DU_LOG("\nINFO --> E2AP : Received RIC subscription failure"); + + SEARCH_DU_DB(duIdx, duId, duDb); + if(duDb == NULLP) { - if(resetReq->protocolIEs.list.array) + DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); + return RFAILED; + } + + memset(&ricReqId, 0, sizeof(RicRequestId)); + if(ricSubscriptionFailure) + { + if(ricSubscriptionFailure->protocolIEs.list.array) { - for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++) + for(ieIdx=0; ieIdxprotocolIEs.list.count; ieIdx++) { - if(resetReq->protocolIEs.list.array[ieIdx]) + if(ricSubscriptionFailure->protocolIEs.list.array[ieIdx]) { - switch(resetReq->protocolIEs.list.array[ieIdx]->id) + ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[ieIdx]; + switch(ricSubscriptionFailure->protocolIEs.list.array[ieIdx]->id) { - case ProtocolIE_IDE2_id_TransactionID: - transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID; + case ProtocolIE_IDE2_id_RICrequestID: + { + ricReqId.requestorId = ricSubsFailIe->value.choice.RICrequestID.ricRequestorID; + ricReqId.instanceId = ricSubsFailIe->value.choice.RICrequestID.ricInstanceID; + ricReqIdDecoded = true; break; - case ProtocolIE_IDE2_id_CauseE2: - DU_LOG("\nDEBUG --> E2AP : Reset reason %d", resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present); - switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present) + } + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsFailIe->value.choice.RANfunctionID; + if(duDb->ranFunction[ranFuncId-1].id == ranFuncId) { - case CauseE2_PR_NOTHING: - break; - case CauseE2_PR_ricRequest: - cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest; - break; - case CauseE2_PR_ricService: - cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService; - break; - case CauseE2_PR_e2Node: - cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node; - break; - case CauseE2_PR_transport: - cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport; - break; - case CauseE2_PR_protocol: - cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol; - break; - case CauseE2_PR_misc: - cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc; - break; + ranFuncDb = &duDb->ranFunction[ranFuncId-1]; } - DU_LOG("\nDEBUG --> E2AP : Reset cause %d", cause); + break; + } + case ProtocolIE_IDE2_id_CauseE2: + default: + /* No handling required as of now since this is a stub */ break; + + } + } + } + + /* Remove subscription entry from RAN Function */ + if(ranFuncDb && ricReqIdDecoded) + { + for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++) + { + if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) && + (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId)) + { + memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription)); + break; } } } } } - BuildAndSendResetResponse(duId, transId); return ROK; } /******************************************************************* * - * @brief deallocate the memory allocated in building the - * Service Query message + * @brief Free the ErrorIndication Message * * @details * - * Function : FreeRicServiceQuery - * - * Functionality: deallocate the memory allocated in building - * Ric Service Query message + * Function : FreeRicIndication * - * @params[in] E2AP_PDU_t *e2apMsg + * Functionality: Free the ErrorIndication Message * * @return void - * ****************************************************************/ - -void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg) + * + * + ******************************************************************/ +void FreeErrorIndication(E2AP_PDU_t *e2apMsg) { - uint8_t arrIdx = 0, ranFuncIdx=0; - RANfunctionsID_List_t *ranFuncAddedList; - RICserviceQuery_t *ricServiceQuery; - - if(e2apMsg) + uint8_t arrIdx = 0; + ErrorIndicationE2_t *errorIndicationMsg= NULLP; + + if(e2apMsg != NULLP) { - if(e2apMsg->choice.initiatingMessage) + if(e2apMsg->choice.initiatingMessage != NULLP) { - ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery; - if(ricServiceQuery->protocolIEs.list.array) + errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2; + if(errorIndicationMsg!= NULLP) { - for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + if(errorIndicationMsg->protocolIEs.list.array != NULLP) { - if(ricServiceQuery->protocolIEs.list.array[arrIdx]) + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) { - switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id) - { - case ProtocolIE_IDE2_id_RANfunctionsAccepted: - { - ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List; - if(ranFuncAddedList->list.array) - { - for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) - { - RIC_FREE(ranFuncAddedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t)); - } - RIC_FREE(ranFuncAddedList->list.array, ranFuncAddedList->list.size); - } - break; - } - case RICserviceQuery_IEs__value_PR_TransactionID: - { - break; - } - } - RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t)); + RIC_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t)); } + RIC_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size); } - RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size); } RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); } @@ -1567,135 +3056,157 @@ void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg) } } + /******************************************************************* * - * @brief build and send the ric service Query + * @brief Builds and Send the ErrorIndication Message * * @details * - * Function : BuildAndSendRicServiceQuery + * Function : BuildAndSendErrorIndication * - * Functionality: build and send the ric service Query + * Functionality:Fills the ErrorIndication Message + * + * @params[in] + * DU id + * Trans id + * Ric req id + * Ran function id + * Reason of failure * @return ROK - success - * RFAILED - Acknowledge + * RFAILED - failure * ******************************************************************/ -uint8_t BuildAndSendRicServiceQuery(DuDb *duDb) +uint8_t BuildAndSendErrorIndication(uint32_t duId, int8_t transId, RicRequestId requestId, uint16_t ranFuncId, uint8_t reason) { - uint8_t arrIdx; - uint8_t elementCnt; - uint8_t ret = RFAILED; - bool memAllocFailed = false; - E2AP_PDU_t *e2apMsg = NULL; - asn_enc_rval_t encRetVal; - RICserviceQuery_t *ricServiceQuery; + uint8_t elementCnt =0, arrIdx=0, ret = RFAILED; + E2AP_PDU_t *e2apMsg = NULLP; + ErrorIndicationE2_t *errorIndicationMsg=NULLP; + asn_enc_rval_t encRetVal; /* Encoder return value */ - DU_LOG("\nINFO --> E2AP : Building Ric service Query\n"); while(true) { + DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n"); + RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); if(e2apMsg == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__); break; } - e2apMsg->present = E2AP_PDU_PR_initiatingMessage; - RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2)); + + e2apMsg->present = E2AP_PDU_PR_initiatingMessage; + RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); if(e2apMsg->choice.initiatingMessage == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__); break; } - - e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery; + e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2; e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; - e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery; - ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery; + e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2; - elementCnt = 1; - /* Fill Accepted RAN function IE If Ran function information is stored in databse */ - if(duDb->numOfRanFunction) + errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2; + + /* Element count is 2 for TransactionID/RICrequestID and Cause. + * If the RAN function id is present, the count will be increased.*/ + elementCnt = 2; + if(ranFuncId>0) elementCnt++; - ricServiceQuery->protocolIEs.list.count = elementCnt; - ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*); + errorIndicationMsg->protocolIEs.list.count = elementCnt; + errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*); - RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size); - if(ricServiceQuery->protocolIEs.list.array == NULLP) + /* Initialize the E2Setup members */ + RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size); + if(errorIndicationMsg->protocolIEs.list.array == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed"); + DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__); break; } - - for(arrIdx=0; arrIdxprotocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t)); - if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP) + RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t)); + if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed"); - memAllocFailed = true; + DU_LOG("\nERROR --> E2AP : Memory allocation failed for array Idx %d in %s at line %d",arrIdx,__func__, __LINE__); break; } } - if(memAllocFailed == true) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed"); + if(arrIdx < elementCnt) break; - } - /* Trans Id */ arrIdx = 0; - ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; - ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; - ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID; - ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb); + + if(transId >=0 && transId<=255) + { + /* TransactionID */ + errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId; + } + else + { + /* RICrequestID */ + errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId; + } - if(duDb->numOfRanFunction) + if(ranFuncId>0) { - /* Accepted RAN function Id */ + /* RAN Function ID */ arrIdx++; - ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted; - ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; - ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List; - if(BuildRanFunctionAddedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK) - { - DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list"); - break; - } + errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId; } - + + /* Cause */ + arrIdx++; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore; + errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2; + fillE2FailureCause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, CauseE2_PR_misc, reason); + + + /* Prints the Msg formed */ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); memset(encBuf, 0, ENC_BUF_MAX_LEN); encBufSize = 0; - encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf); - - /* Check encode results */ + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\ + encBuf); if(encRetVal.encoded == ENCODE_FAIL) { - DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\ + DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); break; } else { - DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n"); + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n"); +#ifdef DEBUG_ASN_PRINT for(int i=0; i< encBufSize; i++) { - DU_LOG("%x",encBuf[i]); + printf("%x",encBuf[i]); } +#endif } - if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK) + if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK) { - DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed"); - break; - } + DU_LOG("\nINFO --> E2AP : Sending Error Indication Message"); - ret =ROK; + } + ret = ROK; break; } - FreeRicServiceQuery(e2apMsg); + FreeErrorIndication(e2apMsg); return ret; } @@ -1780,7 +3291,7 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate: { DU_LOG("\nINFO --> E2AP : E2 node config update received"); - BuildAndSendE2NodeConfigUpdateAck(*duId); + ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate); break; } case InitiatingMessageE2__value_PR_ResetRequestE2: @@ -1794,9 +3305,21 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) DU_LOG("\nINFO --> E2AP : RIC Indication Acknowledged"); break; } + case InitiatingMessageE2__value_PR_RICserviceUpdate: + { + DU_LOG("\nINFO --> E2AP : RIC Service update received"); + ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate); + break; + } + case InitiatingMessageE2__value_PR_ErrorIndicationE2: + { + DU_LOG("\nINFO --> E2AP : Error indication received"); + break; + } default: { - DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]",e2apMsg->choice.initiatingMessage->value.present); + DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \ + e2apMsg->choice.initiatingMessage->value.present); return; } }/* End of switch(initiatingMessage) */ @@ -1808,18 +3331,39 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) { case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse: { - ProcRicSubscriptionResponse(*duId); + ProcRicSubscriptionResponse(*duId, \ + &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse); break; } default: { - DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]",e2apMsg->choice.successfulOutcome->value.present); + DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \ + e2apMsg->choice.successfulOutcome->value.present); return; } break; } break; } + case E2AP_PDU_PR_unsuccessfulOutcome: + { + switch(e2apMsg->choice.successfulOutcome->value.present) + { + case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure: + { + ProcRicSubscriptionFailure(*duId, \ + &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure); + break; + } + default: + { + DU_LOG("\nERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \ + e2apMsg->choice.unsuccessfulOutcome->value.present); + return; + } + } + break; + } default: { DU_LOG("\nERROR --> E2AP : Invalid type message type ");