X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_e2ap_msg_hdl.c;h=e952c5fbe4289a28584dbba019b7b9665a3e1504;hb=112672aee2b176d420e1474b13a5655c3d1e92b4;hp=adedf73cd75d8eac4d2f651c375fa8f6d5648e9e;hpb=66f88e54e39e6b46cfc47bd8afeaea1cb831d0cc;p=o-du%2Fl2.git diff --git a/src/du_app/du_e2ap_msg_hdl.c b/src/du_app/du_e2ap_msg_hdl.c index adedf73cd..e952c5fbe 100644 --- a/src/du_app/du_e2ap_msg_hdl.c +++ b/src/du_app/du_e2ap_msg_hdl.c @@ -40,6 +40,17 @@ #include "E2nodeComponentInterfaceF1.h" #include "E2setupRequest.h" #include "du_e2_conversions.h" +#include "E2SM-KPM-RANfunction-Description.h" +#include "RANfunction-Name.h" +#include "RIC-EventTriggerStyle-Item.h" +#include "RIC-ReportStyle-Item.h" +#include "MeasurementInfo-Action-Item.h" +#include "E2SM-KPM-EventTriggerDefinition.h" +#include "E2SM-KPM-EventTriggerDefinition-Format1.h" +#include "E2SM-KPM-ActionDefinition.h" +#include "E2SM-KPM-ActionDefinition-Format1.h" +#include "MeasurementInfoItem.h" +#include "RANfunctionsIDcause-List.h" /******************************************************************* * @@ -61,10 +72,10 @@ uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId) { uint8_t unused = 0; uint8_t byteSize = 4; - uint8_t gnbId = 1; + uint8_t gnbId = duCb.gnbId; uint8_t ret = ROK; - /* Allocate Buffer size */ + /* fill Global gNB ID Id */ gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t); gNbId->global_gNB_ID.plmn_id.buf = NULLP; DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size); @@ -77,7 +88,6 @@ uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId) { buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \ gNbId->global_gNB_ID.plmn_id.buf); - /* fill gND Id */ gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID; /* Allocate Buffer size */ gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t); @@ -94,6 +104,29 @@ uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId) fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId); } } + + /* fill gNB-DU ID */ + DU_ALLOC( gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t)); + if(gNbId->gNB_DU_ID == NULLP) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID "); + ret = RFAILED; + } + else + { + gNbId->gNB_DU_ID->size = sizeof(uint8_t); + DU_ALLOC( gNbId->gNB_DU_ID->buf, sizeof(uint8_t)); + if(gNbId->gNB_DU_ID->buf) + { + gNbId->gNB_DU_ID->buf[0] =duCb.e2apDb.e2NodeId; + } + else + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID buffer"); + ret = RFAILED; + } + } + return ret; } @@ -131,6 +164,7 @@ CmLList *searchE2NodeComponentInfo(InterfaceType interfaceType, uint8_t componen } return node; } + /******************************************************************* * * @brief Builds E2 node config addition list @@ -259,6 +293,504 @@ uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAdd } +/******************************************************************* + * + * @brief deallocation of E2SM_KPM_RANfunction_Description_t + * + * @details + * + * Function : freeE2smKpmRanFunctionDefinition + * + * Functionality: deallocation of E2SM_KPM_RANfunction_Description_t + * + * @params[in] E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition + * @return void + * + ******************************************************************/ + +void freeE2smKpmRanFunctionDefinition(E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition) +{ + MeasurementInfo_Action_Item_t *measInfoList; + uint8_t eventTriggerIdx, reportStyleIdx, measInfoIdx; + RANfunction_Name_t *ranFuncName; + struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle; + struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *eventTriggerStyle; + if(ranFunctionDefinition) + { + ranFuncName = &ranFunctionDefinition->ranFunction_Name; + /* Free RAN function Name */ + DU_FREE(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size); + DU_FREE(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size); + DU_FREE(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size); + + /* Sequence of Event Trigger styles */ + eventTriggerStyle = ranFunctionDefinition->ric_EventTriggerStyle_List; + if(eventTriggerStyle) + { + if(eventTriggerStyle->list.array) + { + for(eventTriggerIdx =0;eventTriggerIdxlist.count; eventTriggerIdx++) + { + if(eventTriggerStyle->list.array[eventTriggerIdx]) + { + DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.buf,\ + eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.size); + DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx], sizeof(RIC_EventTriggerStyle_Item_t )); + } + } + DU_FREE(eventTriggerStyle->list.array, eventTriggerStyle->list.size) + } + DU_FREE(eventTriggerStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List)); + } + + /* Sequence of Report styles */ + ricReportStyle = ranFunctionDefinition->ric_ReportStyle_List; + if(ricReportStyle) + { + if(ricReportStyle->list.array) + { + for(reportStyleIdx =0;reportStyleIdxlist.count; reportStyleIdx++) + { + if(ricReportStyle->list.array[reportStyleIdx]) + { + if(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf) + { + DU_FREE(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf,\ + ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.size); + } + if(ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array) + { + for(measInfoIdx=0; measInfoIdxlist.array[reportStyleIdx]->measInfo_Action_List.list.count; \ + measInfoIdx++) + { + measInfoList = ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array[measInfoIdx]; + if(measInfoList) + { + DU_FREE(measInfoList->measID, sizeof(long)); + DU_FREE(measInfoList->measName.buf, measInfoList->measName.size); + DU_FREE(measInfoList,sizeof(MeasurementInfo_Action_Item_t)); + } + } + DU_FREE(measInfoList,ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.size); + } + DU_FREE(ricReportStyle->list.array[reportStyleIdx], sizeof(RIC_ReportStyle_Item_t)); + } + } + DU_FREE(ricReportStyle->list.array, ricReportStyle->list.size); + } + DU_FREE(ricReportStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List)); + } + DU_FREE(ranFunctionDefinition, sizeof(E2SM_KPM_RANfunction_Description_t)); + } +} + +/******************************************************************* + * + * @brief fill the e2sm ric report style + * + * @details + * + * Function : fillRicReportStyle + * + * Functionality: fill the report style + * + * @params[in] RanFunction *ranFuncDb, struct + * E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t fillRicReportStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle) +{ + uint8_t styleIdx, measInfoIdx; + MeasurementInfo_Action_List_t *measInfo; + CmLList *node; + + ricReportStyle->list.count = ranFuncDb->numOfReportStyleSupported; + ricReportStyle->list.size = ricReportStyle->list.count * sizeof(RIC_ReportStyle_Item_t*); + DU_ALLOC(ricReportStyle->list.array, ricReportStyle->list.size); + if(!ricReportStyle->list.array) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__); + return RFAILED; + } + + for(styleIdx =0;styleIdxlist.count; styleIdx++) + { + DU_ALLOC(ricReportStyle->list.array[styleIdx], sizeof(RIC_ReportStyle_Item_t)); + if(!ricReportStyle->list.array[styleIdx]) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + return RFAILED; + } + + /* RIC Report Style Type */ + ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType; + + /* RIC Report Style Format Type */ + ricReportStyle->list.array[styleIdx]->ric_ActionFormat_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType; + + /* RIC Report Style Name */ + ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size = strlen(ranFuncDb->reportStyleList[styleIdx].reportStyle.name); + DU_ALLOC(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf,\ + ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size); + if(!ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + return RFAILED; + } + memcpy(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf, ranFuncDb->reportStyleList[styleIdx].reportStyle.name,\ + ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size); + + /* RIC Indication Header Format Type*/ + ricReportStyle->list.array[styleIdx]->ric_IndicationHeaderFormat_Type = ranFuncDb->ricIndicationHeaderFormat; + + /* RIC Indication Message Format Type*/ + ricReportStyle->list.array[styleIdx]->ric_IndicationMessageFormat_Type = ranFuncDb->ricIndicationMessageFormat; + + /* Measurement Info Action List */ + CmLListCp measInfoList =ranFuncDb->reportStyleList[styleIdx].measurementInfoList; + if(!measInfoList.count) + { + continue; + } + + CM_LLIST_FIRST_NODE(&ranFuncDb->reportStyleList[styleIdx].measurementInfoList, node); + measInfo = &ricReportStyle->list.array[styleIdx]->measInfo_Action_List; + + measInfo->list.count = measInfoList.count; + measInfo->list.size = measInfoList.count*sizeof(MeasurementInfo_Action_Item_t*); + DU_ALLOC(measInfo->list.array, measInfo->list.size); + if(!measInfo->list.array) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + return RFAILED; + } + + for(measInfoIdx=0; measInfoIdxlist.count; measInfoIdx++) + { + if(!node) + { + DU_LOG("\nERROR --> E2AP: Measurement info node is null"); + return RFAILED; + } + + DU_ALLOC(measInfo->list.array[measInfoIdx],sizeof(MeasurementInfo_Action_Item_t)); + if(!measInfo->list.array[measInfoIdx]) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + return RFAILED; + } + MeasurementInfoForAction *measInfoForAction= (MeasurementInfoForAction*)node->node; + DU_ALLOC(measInfo->list.array[measInfoIdx]->measID, sizeof(long)); + if(!measInfo->list.array[measInfoIdx]->measID) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + return RFAILED; + } + + memcpy(measInfo->list.array[measInfoIdx]->measID, &measInfoForAction->measurementTypeId,sizeof(long)); + measInfo->list.array[measInfoIdx]->measName.size= strlen(measInfoForAction->measurementTypeName); + DU_ALLOC(measInfo->list.array[measInfoIdx]->measName.buf, measInfo->list.array[measInfoIdx]->measName.size); + if(!measInfo->list.array[measInfoIdx]->measName.size) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + return RFAILED; + } + + memcpy(measInfo->list.array[measInfoIdx]->measName.buf, \ + measInfoForAction->measurementTypeName,\ + measInfo->list.array[measInfoIdx]->measName.size); + node = node->next; + } + + } + return ROK; +} +/******************************************************************* + * + * @brief fill the ric event trigger style + * + * @details + * + * Function : fillRicEventTriggerStyle + * + * Functionality: fill the ric event trigger style + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t fillRicEventTriggerStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *ricEventTriggerStyle) +{ + uint8_t styleIdx; + + ricEventTriggerStyle->list.count = ranFuncDb->numOfEventTriggerStyleSupported; + ricEventTriggerStyle->list.size = ricEventTriggerStyle->list.count* sizeof(RIC_EventTriggerStyle_Item_t *); + DU_ALLOC(ricEventTriggerStyle->list.array, ricEventTriggerStyle->list.size); + if(!ricEventTriggerStyle->list.array) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__); + return RFAILED; + } + + for(styleIdx =0;styleIdxlist.count; styleIdx++) + { + DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx], sizeof(RIC_EventTriggerStyle_Item_t )); + if(!ricEventTriggerStyle->list.array[styleIdx]) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + return RFAILED; + } + ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Type = ranFuncDb->eventTriggerStyleList[styleIdx].styleType; + + ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerFormat_Type = ranFuncDb->eventTriggerStyleList[styleIdx].formatType; + + ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size = strlen(ranFuncDb->eventTriggerStyleList[styleIdx].name); + DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,\ + ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size); + if(!ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + return RFAILED; + } + memcpy(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,ranFuncDb->eventTriggerStyleList[styleIdx].name,\ + ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size); + + } + return ROK; +} + +/******************************************************************* + * + * @brief Builds Ran function item + * + * @details + * + * Function : BuildRanFunctionItem + * + * Functionality: Building RAN function item + * + * @params[in] + * RAN function item that has to be filled + * Stored RAN Function information + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t BuildRanFunctionItem(RANfunction_Item_t *ranFuncItem, RanFunction *ranFuncDb) +{ + uint8_t ret =RFAILED; + RANfunctionDefinition_t *ranFunctionDefinition; + RANfunction_Name_t *ranFuncName; + asn_enc_rval_t encRetVal; + E2SM_KPM_RANfunction_Description_t *ranFuncDefinition; + + while(true) + { + /* RAN function Id*/ + ranFuncItem->ranFunctionID = ranFuncDb->id; + + /* RAN Function Revision*/ + ranFuncItem->ranFunctionRevision = ranFuncDb->revisionCounter; + + /* RAN function OID*/ + ranFuncItem->ranFunctionOID.size = strlen(ranFuncDb->name.serviceModelOID); + DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size); + if(!ranFuncItem->ranFunctionOID.buf) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + break; + } + memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size); + + /* RAN function Definition */ + DU_ALLOC(ranFuncDefinition, sizeof(E2SM_KPM_RANfunction_Description_t)); + if(!ranFuncDefinition) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + break; + } + + /* RAN function Name */ + ranFuncName = &ranFuncDefinition->ranFunction_Name; + + /* RAN function ShortName */ + ranFuncName->ranFunction_ShortName.size = strlen(ranFuncDb->name.shortName); + DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size); + if(!ranFuncName->ranFunction_ShortName.buf) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + break; + } + memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName)); + + /* RAN function E2SM_OID */ + ranFuncName->ranFunction_E2SM_OID.size = strlen(ranFuncDb->name.serviceModelOID); + DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size); + if(!ranFuncName->ranFunction_E2SM_OID.buf) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + break; + } + memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size); + + /* RAN Function Name Description */ + ranFuncName->ranFunction_Description.size = strlen(ranFuncDb->name.description); + DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size); + if(!ranFuncName->ranFunction_Description.buf) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + break; + } + memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size); + + /* RIC Event Trigger Style List */ + DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List)); + if(!ranFuncDefinition->ric_EventTriggerStyle_List) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + break; + } + + if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK) + { + DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style"); + break; + } + + /* RIC Report Style List */ + DU_ALLOC(ranFuncDefinition->ric_ReportStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List)); + if(!ranFuncDefinition->ric_ReportStyle_List) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__); + break; + } + if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK) + { + DU_LOG("\nERROR --> E2AP: failed to fill ric report style"); + break; + } + + /* Encode the F1SetupRequest type as APER */ + xer_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, ranFuncDefinition); + + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_E2SM_KPM_RANfunction_Description, 0, ranFuncDefinition, PrepFinalEncBuf, encBuf); + + /* Encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n"); + for(uint8_t measIeIdx=0; measIeIdx< encBufSize; measIeIdx++) + { + printf("%x",encBuf[measIeIdx]); + } + ranFunctionDefinition = &ranFuncItem->ranFunctionDefinition; + ranFunctionDefinition->size = encBufSize; + DU_ALLOC(ranFunctionDefinition->buf, encBufSize); + if(ranFunctionDefinition->buf == NULLP) + { + DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer"); + break; + } + memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize); + ret = ROK; + break; + } + } + freeE2smKpmRanFunctionDefinition(ranFuncDefinition); + return ret; +} + +/******************************************************************* + * + * @brief Builds Ran function add list based on the procedure code + * + * @details + * + * Function : BuildRanFunctionAddList + * + * Functionality: Building RAN addition addition list + * In case of ProcedureCodeE2_id_E2setup we add all the RAN Function list + * which is present in E2 database. + * In the case of other procedures, we just fill the RAN functions whose ID + * is contained in recvList + * + * @params[in] + * RAN Function list + * Procedure code + * Count of ran functions to be added in the list + * Received list of RAN functions + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList, uint8_t procedureCode, uint8_t count, RanFuncInfo *recvList) +{ + uint16_t id; + RanFunction *ranFuncDb; + uint8_t ranFuncIdx; + RANfunction_ItemIEs_t *ranFuncItemIe; + + /* For ProcedureCodeE2_id_E2setup, the number of RAN function list items is + * equal to the number of ran function entries stored in the database. + * For any other procedure, the RAN function list count is equal + * to the count of ran functions obtained from the function's caller */ + + if(procedureCode == ProcedureCodeE2_id_E2setup) + ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction; + else + ranFunctionsList->list.count = count; + + ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*); + DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size); + if(ranFunctionsList->list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__); + return RFAILED; + } + + for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++) + { + DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t)); + if(ranFunctionsList->list.array[ranFuncIdx] == NULLP) + { + DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__); + return RFAILED; + } + if(procedureCode == ProcedureCodeE2_id_E2setup) + { + /* Getting all of the RAN function's information from DuCb one by one*/ + ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx]; + } + else + { + /* Getting only the RAN function information from DuCb whose Id is + * present in the received array */ + id =recvList[ranFuncIdx].id; + ranFuncDb = &duCb.e2apDb.ranFunction[id-1]; + } + ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx]; + ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item; + ranFuncItemIe->criticality = CriticalityE2_ignore; + ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item; + BuildRanFunctionItem(&ranFuncItemIe->value.choice.RANfunction_Item, ranFuncDb); + } + return ROK; +} + /******************************************************************* * * @brief De Allocate E2 Setup Request Message @@ -278,10 +810,13 @@ uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAdd void FreeE2SetupReq(E2AP_PDU_t *e2apMsg) { uint8_t arrIdx = 0; - uint8_t e2NodeAddListIdx =0; + uint8_t e2NodeAddListIdx =0, ranFuncAddListIdx; E2setupRequest_t *e2SetupReq; E2nodeComponentConfigAddition_List_t *e2NodeAddList; E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem; + RANfunctions_List_t *ranFunctionsList; + RANfunction_ItemIEs_t *ranFuncItemIe; + RANfunction_Item_t *ranFunItem; /* De-allocating Memory */ if(e2apMsg != NULLP) @@ -310,10 +845,16 @@ void FreeE2SetupReq(E2AP_PDU_t *e2apMsg) if(gNbId->global_gNB_ID.plmn_id.buf != NULLP) { DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\ - gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size); + gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size); DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\ gNbId->global_gNB_ID.plmn_id.size); } + + if(gNbId->gNB_DU_ID != NULLP) + { + DU_FREE( gNbId->gNB_DU_ID->buf, gNbId->gNB_DU_ID->size); + DU_FREE(gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t)); + } DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\ choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t)); } @@ -353,6 +894,27 @@ void FreeE2SetupReq(E2AP_PDU_t *e2apMsg) } break; } + case ProtocolIE_IDE2_id_RANfunctionsAdded: + { + ranFunctionsList = &(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List); + if(ranFunctionsList->list.array) + { + for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++) + { + if(ranFunctionsList->list.array[ranFuncAddListIdx]) + { + ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx]; + ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item; + DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size); + DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size); + DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t)); + } + } + DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size); + } + break; + } + default: DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\ (e2SetupReq->protocolIEs.list.array[arrIdx]->id)); @@ -414,7 +976,7 @@ uint8_t BuildAndSendE2SetupReq() e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest; e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest; - elementCnt = 3; + elementCnt = 4; e2SetupReq->protocolIEs.list.count = elementCnt; e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*); @@ -475,14 +1037,25 @@ uint8_t BuildAndSendE2SetupReq() } } + /* RAN Functions Added List */ arrIdx++; + e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded; + e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List; + if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to create RAN Function"); + break; + } + /* E2 Node Component Configuration Addition List */ + arrIdx++; e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition; e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List; if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List))!=ROK) { - DU_LOG("\nERROR --> E2AP : Failed to E2 Node config addition list"); + DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list"); break; } @@ -518,8 +1091,8 @@ uint8_t BuildAndSendE2SetupReq() break; }while(true); - duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId = transId; - duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode; + duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId; + duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode; FreeE2SetupReq(e2apMsg); return ret; @@ -1000,9 +1573,11 @@ uint8_t procE2SetupRsp(E2AP_PDU_t *e2apMsg) case ProtocolIE_IDE2_id_TransactionID: { transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID; - if((duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId == transId) &&\ - (duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode)) - memset(&duCb.e2apDb.e2TransInfo.onGoingTransaction[transId], 0, sizeof(E2TransInfo)); + if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\ + (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode)) + { + memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo)); + } else { DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId); @@ -1054,326 +1629,867 @@ uint8_t procE2SetupRsp(E2AP_PDU_t *e2apMsg) return ROK; } -/****************************************************************** +/******************************************************************* * - * @brief Processes RIC Subscription Req sent by RIC + * @brief Free RIC Subscription Request * * @details * - * Function : procRicSubsReq + * Function : freeAperDecodingOfRicSubsReq * - * Functionality: Processes E2 Setup Response sent by CU + * Functionality : Free RIC Subscription Request * - * @params[in] E2AP_PDU_t ASN decoded E2AP message - * @return ROK - success - * RFAILED - failure + * @return void * - * ****************************************************************/ - -uint8_t procRicSubsReq(E2AP_PDU_t *e2apMsg) + ******************************************************************/ +void freeAperDecodingOfRicSubsReq(RICsubscriptionRequest_t *ricSubscriptionReq) { - uint8_t idx; - uint8_t ied; - uint8_t ret = ROK; - CmLList *ricSubscriptionNode = NULLP; - RICsubscriptionRequest_t *ricSubsReq; - RicSubscription *ricSubscriptionInfo; - RICaction_ToBeSetup_ItemIEs_t *actionItem; + uint8_t idx = 0; + uint8_t elementIdx = 0; + RICsubscriptionDetails_t *subsDetails = NULLP; + RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP; - DU_LOG("\nINFO --> E2AP : RIC Subscription request received"); - ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest; - - for(idx=0; idxprotocolIEs.list.count; idx++) + if(ricSubscriptionReq->protocolIEs.list.array) { - if(ricSubsReq->protocolIEs.list.array[idx]) + for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++) { - switch(ricSubsReq->protocolIEs.list.array[idx]->id) + switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id) { - case ProtocolIE_IDE2_id_RICrequestID: - { - /* TODO :- ricSubscriptionInfo details will be stored based on - * RAN function id, so first we need to search RAN function and then add - * subscription details to that ran function */ - DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription)); - if(!ricSubscriptionInfo) - { - DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo"); - return RFAILED; - } - ricSubscriptionInfo->requestId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID; - ricSubscriptionInfo->requestId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID; - DU_ALLOC(ricSubscriptionNode, sizeof(CmLList)); - if(ricSubscriptionNode) - { - ricSubscriptionNode->node = (PTR) ricSubscriptionInfo; - cmLListAdd2Tail(&duCb.e2apDb.ranFunction[0].subscriptionList,ricSubscriptionNode); - } - break; - } - case ProtocolIE_IDE2_id_RANfunctionID: - { - duCb.e2apDb.ranFunction[0].id = ricSubsReq->protocolIEs.list.array[idx]-> \ - value.choice.RANfunctionID; - break; - } case ProtocolIE_IDE2_id_RICsubscriptionDetails: { - if(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\ - list.array) - { - actionItem =(RICaction_ToBeSetup_ItemIEs_t *)ricSubsReq->protocolIEs.list\ - .array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List\ - .list.array[0]; + subsDetails = &(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails); + free(subsDetails->ricEventTriggerDefinition.buf); - for(ied = 0; ied < ricSubsReq->protocolIEs.list.array[idx]->value.choice.\ - RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count; ied++) + if(subsDetails->ricAction_ToBeSetup_List.list.array) + { + for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++) { - switch(actionItem->id) + if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]) { - case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item: - { - ricSubscriptionInfo->actionSequence[0].id = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID; - ricSubscriptionInfo->actionSequence[0].type = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType; - break; - } - default: - DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id); - break; + actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.\ + list.array[elementIdx]; + if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) + { + free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf); + free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition); + } + free(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]); } - free(actionItem); } - free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\ - list.array); + free(subsDetails->ricAction_ToBeSetup_List.list.array); } break; } - - default: - DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld", - ricSubsReq->protocolIEs.list.array[idx]->id); - break; } - free(ricSubsReq->protocolIEs.list.array[idx]); + free(ricSubscriptionReq->protocolIEs.list.array[idx]); } + free(ricSubscriptionReq->protocolIEs.list.array); } - free(ricSubsReq->protocolIEs.list.array); - ret = BuildAndSendRicSubscriptionRsp(); - { - BuildAndSendRicIndication(ricSubscriptionInfo); - } - - return ret; } /******************************************************************* * - * @brief Free the RicIndication Message + * @brief Free Event Trigger Definition * * @details * - * Function : FreeRicIndication + * Function : freeAperDecodingOfEventTriggerDef * - * Functionality: Free the RicIndication Message + * Functionality: Free Event Trigger Definition * + * @params[in] E2SM-KPM Event Trigger Definition * @return void - * * - ******************************************************************/ -void FreeRicIndication(E2AP_PDU_t *e2apMsg) + * ****************************************************************/ +void freeAperDecodingOfEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef) { - uint8_t idx=0; - RICindication_t *ricIndicationMsg= NULLP; - - - if(e2apMsg != NULLP) + if(eventTiggerDef) { - if(e2apMsg->choice.initiatingMessage != NULLP) + switch(eventTiggerDef->eventDefinition_formats.present) { - ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication; - if(ricIndicationMsg!= NULLP) - { - if(ricIndicationMsg->protocolIEs.list.array != NULLP) - { - for(idx=0; idxprotocolIEs.list.count; idx++) - { - if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP) - { - switch(ricIndicationMsg->protocolIEs.list.array[idx]->id) - { - case ProtocolIE_IDE2_id_RICrequestID: - break; - - case ProtocolIE_IDE2_id_RANfunctionID: - break; - - case ProtocolIE_IDE2_id_RICactionID: - break; - - case ProtocolIE_IDE2_id_RICindicationType: - break; + case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING: + break; - case ProtocolIE_IDE2_id_RICindicationHeader: - { - DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\ - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size); - break; - } - case ProtocolIE_IDE2_id_RICindicationMessage: - { - DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\ - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size); - break; - } - default: - break; - } - DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t)); - } - } - DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size); - } - } - DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1: + free(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1); + break; } - DU_FREE(e2apMsg, sizeof(E2AP_PDU_t)); } } + /******************************************************************* * - * brief Fill the RicIndication Message + * @brief Extract E2SM-KPM Event trigger definition * * @details * - * Function : FillRicIndication + * Function : extractEventTriggerDef * - * Functionality:Fills the RicIndication Message + * Functionality : This function : + * - Decodes E2SM-KPM Event Trigger Definition + * - Validates that even trigger style is supported by E2 node + * - Stores event trigger details in local DB * + * @params[in] RAN Function Database structure + * RIC Subscription Info to be added to RAN function + * RIC Event Trigger Definition buffer received from RIC * @return ROK - success * RFAILED - failure * ******************************************************************/ -uint8_t FillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo) +uint8_t extractEventTriggerDef(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, RICeventTriggerDefinition_t *ricEventTriggerDef) { - uint8_t elementCnt=0; - uint8_t idx=0; - uint8_t ret = ROK; - elementCnt = 6; + uint8_t ret = RFAILED; + uint8_t eventIdx = 0; + asn_dec_rval_t rval ={0}; + E2SM_KPM_EventTriggerDefinition_t eventTiggerDef, *eventTiggerDefPtr = NULLP; - ricIndicationMsg->protocolIEs.list.count = elementCnt; - ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_t); - /* Initialize the Ric Indication members */ - DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, \ - ricIndicationMsg->protocolIEs.list.size); - if(ricIndicationMsg->protocolIEs.list.array == NULLP) + /* Decoding E2SM-KPM Even Trigger Definition */ + eventTiggerDefPtr = &eventTiggerDef; + memset(eventTiggerDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t)); + + rval = aper_decode(0, &asn_DEF_E2SM_KPM_EventTriggerDefinition, (void **)&eventTiggerDefPtr, ricEventTriggerDef->buf,\ + ricEventTriggerDef->size, 0, 0); + if(rval.code == RC_FAIL || rval.code == RC_WMORE) { - DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed"); - ret = RFAILED; + DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Event Trigger Definition"); + return RFAILED; } - else + printf("\n"); + xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, eventTiggerDefPtr); + + /* Validating the received event trigger definition format */ + for(eventIdx = 0; eventIdx < ranFuncDb->numOfEventTriggerStyleSupported; eventIdx++) { - for(idx=0; idxeventDefinition_formats.present != \ + E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING) && \ + (eventTiggerDefPtr->eventDefinition_formats.present == ranFuncDb->eventTriggerStyleList[eventIdx].formatType)) { - DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx],\ - sizeof(RICindication_IEs_t)); - if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed"); - ret = RFAILED; - } + ricSubscriptionInfo->eventTriggerDefinition.formatType = ranFuncDb->eventTriggerStyleList[eventIdx].formatType; + ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod = \ + eventTiggerDefPtr->eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod; + + ret = ROK; + break; } - if(ret != RFAILED) - { - idx = 0; + } - ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID; - ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ - RICindication_IEs__value_PR_RICrequestID; - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID =ricSubscriptionInfo->requestId.requestorId; - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = ricSubscriptionInfo->requestId.instanceId; + /* Free E2SM_KPM_EventTriggerDefinition_t */ + freeAperDecodingOfEventTriggerDef(eventTiggerDefPtr); + return ret; +} - idx++; - ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID; - ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ - RICindication_IEs__value_PR_RANfunctionID; - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = duCb.e2apDb.ranFunction[0].id; +/******************************************************************* + * + * @brief Free RIC Action Definition + * + * @details + * + * Function : freeAperDecodingOfRicActionDefinition + * + * Functionality: Free RIC Action Definition + * + * @params[in] E2SM-KPM Action definition + * @return void + * + * ****************************************************************/ +void freeAperDecodingOfRicActionDefinition(E2SM_KPM_ActionDefinition_t *actionDef) +{ + uint8_t elementIdx = 0; + E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP; + MeasurementInfoItem_t *measItem = NULLP; - idx++; - ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID; - ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ - RICindication_IEs__value_PR_RICactionID; - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = ricSubscriptionInfo->actionSequence[0].id; + switch(actionDef->actionDefinition_formats.present) + { + 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: + break; - idx++; - ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType; - ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ - RICindication_IEs__value_PR_RICindicationType; - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = ricSubscriptionInfo->actionSequence[0].type; + case MeasurementType_PR_measName: + { + free(measItem->measType.choice.measName.buf); + break; + } - idx++; - ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader; - ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ - RICindication_IEs__value_PR_RICindicationHeader; - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size = 3 * - sizeof(uint8_t); - DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf ,\ - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size); - if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed"); - ret = RFAILED; - } - else - { - buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \ - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf); - idx++; - /* TO BE CHANGED: RIC INDICATION DATA */ - /* For now filling a dummy octect data, need to tested with PRBs*/ - ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage; - ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ - RICindication_IEs__value_PR_RICindicationMessage; - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size = 3 * - sizeof(uint8_t); - DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf ,\ - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size); - if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed"); - ret = RFAILED; - } - else - { - buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \ - ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf); - } - } - } + case MeasurementType_PR_measID: + break; + } + free(measItem); + } + } + free(actionFormat1->measInfoList.list.array); + } + free(actionFormat1); + } + 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: + default: + break; } - return ret; } /******************************************************************* * - * @brief Builds and Send the RicIndication Message + * @brief Extract Measurement Info list from action definition * * @details * - * Function : BuildAndSendRicIndication + * Function : extractMeasInfoList * - * Functionality:Fills the RicIndication Message + * Functionality : This function : + * - Traverses Measurement-to-be-subscribed list + * - Validates that each measurement in Measurement-to-be-subscribed + * list is supported in RAN-Function->Measurement-supported list. + * - If all measurements in an action is supported by RAN function, + * it is added to measurement-subscribed list in local DB * + * @params[in] Measurement Info supported list by RAN function + * Measurement Info to be subscribed as requested by RIC + * Measurement Info finally subscribed + * Memory failure indicator * @return ROK - success * RFAILED - failure * ******************************************************************/ - -uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo) +uint8_t extractMeasInfoList(CmLListCp *measInfoSupportedList, MeasurementInfoList_t *measInfoToBeSubscribedList, \ + CmLListCp *measInfoSubscribedList, bool *memFailure) +{ + uint8_t elementIdx = 0; + MeasurementInfoForAction *measInfoSupportedDb = NULLP; + MeasurementInfo *measInfoSubscribedDb = NULLP, *measInfoToDel = NULLP; + CmLList *supportedMeasNode = NULLP, *measToAddNode = NULLP, *measToDelNode = NULLP;; + MeasurementInfoItem_t *measItem = NULLP; + + /* Validate Measurement list is supported by E2 node. + * + * Traverse and compare the Measurement-Supported List in E2 + * node with Measurement-to-be-subscribed list received from RIC. + * If a match is found, add it to measurement-subscription list. + */ + for(elementIdx = 0; elementIdx < measInfoToBeSubscribedList->list.count; elementIdx++) + { + measInfoSubscribedDb = NULLP; + measToAddNode = NULLP; + measItem = measInfoToBeSubscribedList->list.array[elementIdx]; + + CM_LLIST_FIRST_NODE(measInfoSupportedList, supportedMeasNode); + while(supportedMeasNode) + { + measInfoSupportedDb = (MeasurementInfoForAction*)supportedMeasNode->node; + switch(measItem->measType.present) + { + case MeasurementType_PR_measName: + { + if(!strcmp(measInfoSupportedDb->measurementTypeName, (char *)measItem->measType.choice.measName.buf)) + { + DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo)); + } + break; + } + + case MeasurementType_PR_measID: + { + if(measInfoSupportedDb->measurementTypeId == measItem->measType.choice.measID) + { + DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo)); + } + break; + } + + default: + { + DU_LOG("\nERROR -> DUAPP: Invalid Measurement-type identifier in \ + E2SM-KPM Action Definition Format"); + break; + } + } /* End of switch, for measurement type identifier */ + + /* If measurement type is supported, add to measurement-subscription list */ + if(measInfoSubscribedDb) + { + measInfoSubscribedDb->measurementTypeId = measInfoSupportedDb->measurementTypeId; + memcpy(measInfoSubscribedDb->measurementTypeName, measInfoSupportedDb->measurementTypeName, \ + strlen(measInfoSupportedDb->measurementTypeName)); + + DU_ALLOC(measToAddNode, sizeof(CmLList)); + if(measToAddNode) + { + measToAddNode->node = (PTR) measInfoSubscribedDb; + cmLListAdd2Tail(measInfoSubscribedList, measToAddNode); + + /* Break out of while loop if measurement info is found in measurement-supported list */ + break; + } + else + { + DU_FREE(measInfoSubscribedDb, sizeof(MeasurementInfo)); + measInfoSubscribedDb = NULLP; + *memFailure = true; + break; + } + } + + supportedMeasNode = supportedMeasNode->next; + + } /* End of while for traversing measurement-supported list in a report style */ + + /* If a measurement-to-be-subscribed is not found in measurement-supported list in this report style + * Then : + * Delete all entries from measurement-subscription list and + * Break out of for loop to search in next report style */ + if(!measInfoSubscribedDb) + { + while(measInfoSubscribedList->count) + { + measToDelNode = cmLListDelFrm(measInfoSubscribedList, measInfoSubscribedList->first); + measInfoToDel = (MeasurementInfo*)measToDelNode->node; + DU_FREE(measInfoToDel, sizeof(MeasurementInfo)); + DU_FREE(measToDelNode, sizeof(CmLList)); + } + break; + } + + } /* End of for loop , traversing measurement-to-be-subscribed list */ + + /* If all measurement-to-be-subscribed was found in measurement-supported list and + * was added to measurement-subscription list successfully, return from here */ + if(measInfoToBeSubscribedList->list.count == measInfoSubscribedList->count) + return ROK; + + return RFAILED; +} + +/******************************************************************* + * + * @brief Extract E2SM-KPM Action definition + * + * @details + * + * Function : extractRicActionDef + * + * Functionality : This function : + * - Decodes E2SM-KPM Action Definition + * - Validates that action is supported by E2 node + * - Stores action details in local DB + * + * @params[in] RAN Function Database structure + * RIC subscription's Action definition to be added to + * RAN function + * RIC Action Definition buffer received from RIC + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefDb, RICactionDefinition_t *ricActionDef) +{ + bool memFailure = false; + uint8_t styleIdx = 0; + asn_dec_rval_t rval ={0}; + + E2SM_KPM_ActionDefinition_t actionDef, *actionDefPtr = NULLP; + E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP; + CmLListCp *measInfoSupportedList = NULLP; + CmLListCp *measInfoSubscribedList = NULLP; + + /* Decoding E2SM-KPM Action Definition */ + actionDefPtr = &actionDef; + memset(actionDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t)); + + rval = aper_decode(0, &asn_DEF_E2SM_KPM_ActionDefinition, (void **)&actionDefPtr, ricActionDef->buf,\ + ricActionDef->size, 0, 0); + if(rval.code == RC_FAIL || rval.code == RC_WMORE) + { + DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Action Definition"); + return RFAILED; + } + printf("\n"); + xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDefPtr); + + + /* Validate if Report style to subscribe is supported by E2 Node */ + for(styleIdx= 0; styleIdx < ranFuncDb->numOfReportStyleSupported; styleIdx++) + { + /* Validate Report style type and report style format type is supported by E2 Node */ + if((ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType == actionDefPtr->ric_Style_Type) && + (ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType == actionDefPtr->actionDefinition_formats.present)) + { + /* Fetch Report stype type and format type */ + actionDefDb->styleType = actionDefPtr->ric_Style_Type; + actionDefDb->formatType = actionDefPtr->actionDefinition_formats.present; + + switch(actionDefPtr->actionDefinition_formats.present) + { + case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1: + { + actionFormat1 = actionDefPtr->actionDefinition_formats.choice.actionDefinition_Format1; + + /* Fetch granularity period */ + actionDefDb->choice.format1.granularityPeriod = actionFormat1->granulPeriod; + + /* Validate and add the Measurement to subscription list */ + measInfoSupportedList = &ranFuncDb->reportStyleList[styleIdx].measurementInfoList; + measInfoSubscribedList = &actionDefDb->choice.format1.measurementInfoList; + if(extractMeasInfoList(measInfoSupportedList, &actionFormat1->measInfoList, \ + measInfoSubscribedList, &memFailure) == ROK) + { + if(!memFailure) + { + /* Free E2SM_KPM_ActionDefinition_t */ + freeAperDecodingOfRicActionDefinition(actionDefPtr); + return ROK; + } + } + + break; /* End of E2SM-KPM Action definition format 1 case */ + } + + default : + { + DU_LOG("\nERROR -> DUAPP: Only E2SM-KPM Action Definition Format 1 is supported"); + break; + } + } /* End of switch for E2SM-KPM Action definition formats */ + } + + if(memFailure) + break; + } /* End of for loop, traversing Report-styles-supported list in E2 node */ + + /* Memset action Db and Free E2SM_KPM_ActionDefinition_t */ + memset(actionDefDb, 0, sizeof(ActionDefinition)); + freeAperDecodingOfRicActionDefinition(actionDefPtr); + return RFAILED; +} + +/******************************************************************* + * + * @brief Extract RIC Action to be setup + * + * @details + * + * Function : extractRicActionToBeSetup + * + * Functionality : This function : + * - Validates that each action-to-be-setup is supported by E2 node + * - Stores event trigger details in local DB + * + * @params[in] RAN Function Database structure + * RIC Subscription Info to be added to RAN function + * RIC Action To Be Setup List received from RIC + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, RICactions_ToBeSetup_List_t *actionList) +{ + uint8_t actionIdx = 0; + uint8_t ricActionId = 0; + RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP; + + if(actionList->list.array) + { + for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++) + { + actionItem =(RICaction_ToBeSetup_ItemIEs_t *)actionList->list.array[actionIdx]; + switch(actionItem->id) + { + case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item: + { + /* If Action type is REPORT and + * If RIC action definition's extraction and validation passes, + * Then : + * This action is added to action sequence list of subscription info */ + if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType == RICactionType_report) + { + ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID; + ricSubscriptionInfo->actionSequence[ricActionId-1].id = ricActionId; + ricSubscriptionInfo->actionSequence[ricActionId-1].type = REPORT; + + if(extractRicActionDef(ranFuncDb, &ricSubscriptionInfo->actionSequence[ricActionId-1].definition, \ + actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) == ROK) + { + ricSubscriptionInfo->actionSequence[ricActionId-1].action = CONFIG_ADD; + ricSubscriptionInfo->numOfActions++; + } + else + { + memset(&ricSubscriptionInfo->actionSequence[ricActionId-1], 0, sizeof(ActionInfo)); + /* TODO : Since this action addition failed, add to + * reject-action-list in subscription response */ + } + } + break; + } + default: + DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id); + break; + } + } + } + + /* If there is even 1 action that can be added, return ROK */ + if(ricSubscriptionInfo->numOfActions) + return ROK; + + return RFAILED; +} + +/****************************************************************** + * + * @brief Processes RIC Subscription Req sent by RIC + * + * @details + * + * Function : procRicSubsReq + * + * Functionality: Processes E2 Setup Response sent by CU + * + * @params[in] E2AP_PDU_t ASN decoded E2AP message + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t procRicSubsReq(E2AP_PDU_t *e2apMsg) +{ + uint8_t idx = 0; + uint8_t ret = ROK; + uint16_t ranFuncId = 0; + CmLList *ricSubscriptionNode = NULLP; + RanFunction *ranFuncDb = NULLP; + RICsubscriptionRequest_t *ricSubsReq = NULLP; + RICsubscriptionDetails_t *subsDetails = NULLP; + RicSubscription *ricSubscriptionInfo = NULLP; + + DU_LOG("\nINFO --> E2AP : RIC Subscription request received"); + ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest; + + for(idx=0; idxprotocolIEs.list.count; idx++) + { + if(ricSubsReq->protocolIEs.list.array[idx]) + { + switch(ricSubsReq->protocolIEs.list.array[idx]->id) + { + case ProtocolIE_IDE2_id_RICrequestID: + { + DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription)); + if(!ricSubscriptionInfo) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo"); + ret = RFAILED; + break; + } + ricSubscriptionInfo->requestId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID; + ricSubscriptionInfo->requestId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID; + + break; + } + + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID; + + /* Validating RAN Function id */ + if(duCb.e2apDb.ranFunction[ranFuncId-1].id == ranFuncId) + { + ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncId-1]; + } + else + { + /* TODO : Send RAN Subcription Failure */ + ret = RFAILED; + } + break; + } + + case ProtocolIE_IDE2_id_RICsubscriptionDetails: + { + subsDetails = &ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails; + + /* Decode, Validate and record Event Trigger Definition */ + if(extractEventTriggerDef(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricEventTriggerDefinition) != ROK) + { + /* TODO : Send RAN Subcription Failure */ + ret = RFAILED; + break; + } + + /* Decode, Validate and record RIC actions */ + if(extractRicActionToBeSetup(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricAction_ToBeSetup_List) != ROK) + { + /* TODO : Send RAN Subcription Failure */ + ret = RFAILED; + break; + } + } + break; + + default: + DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld", + ricSubsReq->protocolIEs.list.array[idx]->id); + break; + } + + if(ret == RFAILED) + break; + } + } + + freeAperDecodingOfRicSubsReq(ricSubsReq); + + if(ret == ROK) + { + /* Add RAN subcription detail to RAN function */ + DU_ALLOC(ricSubscriptionNode, sizeof(CmLList)); + if(ricSubscriptionNode) + { + ricSubscriptionNode->node = (PTR) ricSubscriptionInfo; + cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubscriptionNode); + } + +#ifdef KPI_CALCULATION + /* Send statistics request to other DU entities */ + BuildAndSendStatsReq(ranFuncId, ricSubscriptionInfo); +#endif + + /* TODO : Trigger RIC subscription response once statistics response is + * received from MAC . + * TBD in next gerrit */ + ret = BuildAndSendRicSubscriptionRsp(); + { + BuildAndSendRicIndication(ricSubscriptionInfo); + } + } + + return ret; +} + +/******************************************************************* + * + * @brief Free the RicIndication Message + * + * @details + * + * Function : FreeRicIndication + * + * Functionality: Free the RicIndication Message + * + * @return void + * + * + ******************************************************************/ +void FreeRicIndication(E2AP_PDU_t *e2apMsg) +{ + uint8_t idx = 0; + RICindication_t *ricIndicationMsg= NULLP; + + if(e2apMsg != NULLP) + { + if(e2apMsg->choice.initiatingMessage != NULLP) + { + ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication; + if(ricIndicationMsg!= NULLP) + { + if(ricIndicationMsg->protocolIEs.list.array != NULLP) + { + for(idx=0; idxprotocolIEs.list.count; idx++) + { + if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP) + { + switch(ricIndicationMsg->protocolIEs.list.array[idx]->id) + { + case ProtocolIE_IDE2_id_RICrequestID: + break; + + case ProtocolIE_IDE2_id_RANfunctionID: + break; + + case ProtocolIE_IDE2_id_RICactionID: + break; + + case ProtocolIE_IDE2_id_RICindicationType: + break; + + case ProtocolIE_IDE2_id_RICindicationHeader: + { + DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\ + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size); + break; + } + case ProtocolIE_IDE2_id_RICindicationMessage: + { + DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\ + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size); + break; + } + default: + break; + } + DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t)); + } + } + DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size); + } + } + DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + } + DU_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* + * + * brief Fill the RicIndication Message + * + * @details + * + * Function : FillRicIndication + * + * Functionality:Fills the RicIndication Message + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t FillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo) +{ + uint8_t elementCnt=0; + uint8_t idx=0; + uint8_t ret = ROK; + elementCnt = 6; + + ricIndicationMsg->protocolIEs.list.count = elementCnt; + ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_t); + /* Initialize the Ric Indication members */ + DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, \ + ricIndicationMsg->protocolIEs.list.size); + if(ricIndicationMsg->protocolIEs.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed"); + ret = RFAILED; + } + else + { + for(idx=0; idxprotocolIEs.list.array[idx],\ + sizeof(RICindication_IEs_t)); + if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed"); + ret = RFAILED; + } + } + if(ret != RFAILED) + { + idx = 0; + + ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID; + ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ + RICindication_IEs__value_PR_RICrequestID; + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID =ricSubscriptionInfo->requestId.requestorId; + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = ricSubscriptionInfo->requestId.instanceId; + + idx++; + ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID; + ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ + RICindication_IEs__value_PR_RANfunctionID; + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = duCb.e2apDb.ranFunction[0].id; + + idx++; + ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID; + ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ + RICindication_IEs__value_PR_RICactionID; + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = ricSubscriptionInfo->actionSequence[0].id; + + idx++; + ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType; + ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ + RICindication_IEs__value_PR_RICindicationType; + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = ricSubscriptionInfo->actionSequence[0].type; + + idx++; + ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader; + ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ + RICindication_IEs__value_PR_RICindicationHeader; + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size = 3 * + sizeof(uint8_t); + DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf ,\ + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size); + if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed"); + ret = RFAILED; + } + else + { + buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \ + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf); + idx++; + /* TO BE CHANGED: RIC INDICATION DATA */ + /* For now filling a dummy octect data, need to tested with PRBs*/ + ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage; + ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; + ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \ + RICindication_IEs__value_PR_RICindicationMessage; + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size = 3 * + sizeof(uint8_t); + DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf ,\ + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size); + if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed"); + ret = RFAILED; + } + else + { + buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \ + ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf); + } + } + } + } + return ret; +} + +/******************************************************************* + * + * @brief Builds and Send the RicIndication Message + * + * @details + * + * Function : BuildAndSendRicIndication + * + * Functionality:Fills the RicIndication Message + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ + +uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo) { E2AP_PDU_t *e2apMsg = NULLP; RICindication_t *ricIndicationMsg=NULLP; @@ -1381,257 +2497,810 @@ uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo) uint8_t ret = RFAILED; uint8_t FillRicIndicationret = ROK; - while(true) - { - DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n"); + while(true) + { + DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n"); + + DU_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; + DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + if(e2apMsg->choice.initiatingMessage == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + break; + } + e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication; + e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; + e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication; + + ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication; + + FillRicIndicationret = FillRicIndication(ricIndicationMsg, ricSubscriptionInfo); + if(FillRicIndicationret != ROK) + { + break; + } + /* Prints the Msg formed */ + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\ + encBuf); + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode RIC 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 Indication Message \n"); +#ifdef DEBUG_ASN_PRINT + for(int i=0; i< encBufSize; i++) + { + printf("%x",encBuf[i]); + } +#endif + } + + if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK) + { + DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message"); + + } + ret = ROK; + break; + } + FreeRicIndication(e2apMsg); + return ret; +} + +/******************************************************************* + * + * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg + * + * @details + * + * Function : FreeE2NodeConfigUpdate + * + * Functionality: + * - freeing the memory allocated for E2nodeConfigurationUpdate + * + * @params[in] E2AP_PDU_t *e2apMsg + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg) +{ + uint8_t arrIdx =0; + E2nodeConfigurationUpdate_t *e2NodeConfigUpdate; + + if(e2apMsg != NULLP) + { + if(e2apMsg->choice.initiatingMessage != NULLP) + { + e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate; + if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP) + { + for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++) + { + DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t)); + } + DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size); + } + DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + } + DU_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* + * + * @brief Buld and send the E2 node config update msg + * + * @details + * + * Function : BuildAndSendE2NodeConfigUpdate + * + * Functionality: + * - Buld and send the E2 node config update msg + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t BuildAndSendE2NodeConfigUpdate() +{ + uint8_t arrIdx = 0,elementCnt = 1; + uint8_t ret = ROK; + E2AP_PDU_t *e2apMsg = NULLP; + E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP; + asn_enc_rval_t encRetVal; /* Encoder return value */ + + DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n"); + do + { + DU_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; + DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + if(e2apMsg->choice.initiatingMessage == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + DU_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + return RFAILED; + } + e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; + e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate; + e2apMsg->choice.initiatingMessage->value.present = \ + InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate; + e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate; + + e2NodeConfigUpdate->protocolIEs.list.count = elementCnt; + e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*); + /* Initialize the Ric Indication members */ + DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, \ + e2NodeConfigUpdate->protocolIEs.list.size); + if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed"); + break; + } + + for(arrIdx =0; arrIdxprotocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t)); + if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP) + { + + DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed"); + break; + } + } + + arrIdx = 0; + /* TransactionID */ + e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; + e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID; + e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID; + + + /* Prints the Msg formed */ + xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); + + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\ + encBuf); + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n"); +#ifdef DEBUG_ASN_PRINT + for(int i=0; i< encBufSize; i++) + { + printf("%x",encBuf[i]); + } +#endif + } + if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize)) + { + DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed"); + return RFAILED; + } + + break; + }while(true); + + FreeE2NodeConfigUpdate(e2apMsg); + return ret; +} + +/******************************************************************* + * + * @brief Deallocate the memory allocated for E2ResetRequest msg + * + * @details + * + * Function : FreeE2ResetRequest + * + * Functionality: + * - freeing the memory allocated for E2ResetRequest + * + * @params[in] E2AP_PDU_t *e2apMsg + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg) +{ + uint8_t ieIdx =0; + ResetRequestE2_t *resetReq = NULLP; + + if(e2apMsg != NULLP) + { + if(e2apMsg->choice.initiatingMessage != NULLP) + { + resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2; + if(resetReq->protocolIEs.list.array) + { + for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++) + { + DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t)); + } + DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size); + } + DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + } + DU_FREE(e2apMsg, sizeof(E2AP_PDU_t)); + } +} + +/******************************************************************* + * + * @brief Build and send the E2 reset request msg + * + * @details + * + * Function : BuildAndSendE2ResetRequest + * + * Functionality: + * - Buld and send the E2 reset request msg to RIC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t BuildAndSendE2ResetRequest(E2CauseType failureType, E2Cause failureCause) +{ + uint8_t ieIdx = 0, elementCnt = 0, transId = 0; + uint8_t ret = RFAILED; + E2AP_PDU_t *e2apMsg = NULLP; + ResetRequestE2_t *resetReq = NULLP; + asn_enc_rval_t encRetVal; /* Encoder return value */ + + DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n"); + do + { DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); if(e2apMsg == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); - break; + DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed"); + break; } e2apMsg->present = E2AP_PDU_PR_initiatingMessage; DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); if(e2apMsg->choice.initiatingMessage == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); - break; + DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage"); + break; } - e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication; + + e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset; e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; - e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication; + e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2; + resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2; - ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication; + elementCnt = 2; + resetReq->protocolIEs.list.count = elementCnt; + resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *); - FillRicIndicationret = FillRicIndication(ricIndicationMsg, ricSubscriptionInfo); - if(FillRicIndicationret != ROK) + DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size); + if(!resetReq->protocolIEs.list.array) { - break; + DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \ + Reset Request IE array"); + break; + } + + for(ieIdx = 0; ieIdx < elementCnt; ieIdx++) + { + DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t)); + if(!resetReq->protocolIEs.list.array[ieIdx]) + { + DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \ + Reset Request IE array element"); + break; + } + } + + /* In case of failure */ + if(ieIdx < elementCnt) + break; + + ieIdx = 0; + resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID; + resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject; + resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID; + transId = assignTransactionId(); + resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId; + + ieIdx++; + resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2; + resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore; + resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2; + resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present = failureType; + switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present) + { + case CauseE2_PR_NOTHING: + break; + case CauseE2_PR_ricRequest: + resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest = failureCause; + break; + case CauseE2_PR_ricService: + resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService = failureCause; + break; + case CauseE2_PR_e2Node: + resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node = failureCause; + break; + case CauseE2_PR_transport: + resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport = failureCause; + break; + case CauseE2_PR_protocol: + resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol = failureCause; + break; + case CauseE2_PR_misc: + resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc = failureCause; + break; } + /* 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); + encBuf); if(encRetVal.encoded == ENCODE_FAIL) { - DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\ - encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); - break; + DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; } else { - DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n"); + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n"); #ifdef DEBUG_ASN_PRINT - for(int i=0; i< encBufSize; i++) - { - printf("%x",encBuf[i]); - } + for(int i=0; i< encBufSize; i++) + { + printf("%x",encBuf[i]); + } #endif } - if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK) { - DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message"); - + DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed"); + break; } + + /* In case the message is sent successfully, store the transaction info to + * be used when response is received */ + duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId; + duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode; + ret = ROK; break; - } - FreeRicIndication(e2apMsg); + }while(true); + + /* Free all memory */ + FreeE2ResetRequest(e2apMsg); return ret; } - -/******************************************************************* + +/******************************************************************* + * + * @brief Deallocate the memory allocated for Reset Response msg + * + * @details + * + * Function : freeAperDecodingOfE2ResetRsp + * + * Functionality: + * - freeing the memory allocated for Reset response + * + * @params[in] ResetResponseE2_t *resetResponse + * @return void + * + * ****************************************************************/ +void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse) +{ + uint8_t ieIdx; + + if(resetResponse) + { + if(resetResponse->protocolIEs.list.array) + { + for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++) + { + if(resetResponse->protocolIEs.list.array[ieIdx]) + { + switch(resetResponse->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_TransactionID: + break; + + case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2: + break; + } + free(resetResponse->protocolIEs.list.array[ieIdx]); + } + } + free(resetResponse->protocolIEs.list.array); + } + } +} + +/****************************************************************** + * + * @brief Processes E2 Reset Response sent by RIC + * + * @details + * + * Function : procResetResponse + * + * Functionality: Processes E2 Reset Response sent by RIC + * + * @params[in] E2AP_PDU_t ASN decoded E2AP message + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t procResetResponse(E2AP_PDU_t *e2apMsg) +{ + uint8_t ieIdx =0, transId; + ResetResponseE2_t *resetResponse; + + DU_LOG("\nINFO --> E2AP : E2 Reset Response received"); + resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;; + + for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++) + { + switch(resetResponse->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_TransactionID: + transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID; + if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \ + (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode)) + { + memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo)); + } + else + { + DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId); + return RFAILED; + } + break; + case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2: + /* As per ORAN WG3 E2AP spec v3.0, section 9.2.2 + Criticality Diagnostics IE is sent by Near-RT RIC when parts of a received message i.e. + Reset Request in this case, have not been comprehended or were missing, or if the message + contained logical errors. + + Processing of this ID should be implemented when negative call flows are to be supported. + */ + break; + default: + DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld", + resetResponse->protocolIEs.list.array[ieIdx]->id); + break; + } + } + + freeAperDecodingOfE2ResetRsp(resetResponse); + return ROK; +} + +/****************************************************************** + * + * @brief Deallocation of memory allocated bu aper decoder for e2 setup Failure + * + * @details + * + * Function : freeAperDecodingOfE2SetupFailure + * + * Functionality: Deallocation of memory allocated bu aper decoder for e2 + * setup Failure + * + * @params[in] E2setupFailure_t *e2SetupFailure; + * @return void + * + * ****************************************************************/ +void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure) +{ + uint8_t arrIdx; + + if(e2SetupFailure) + { + if(e2SetupFailure->protocolIEs.list.array) + { + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + { + if(e2SetupFailure->protocolIEs.list.array[arrIdx]) + { + free(e2SetupFailure->protocolIEs.list.array[arrIdx]); + } + } + free(e2SetupFailure->protocolIEs.list.array); + } + } +} +/****************************************************************** * - * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg + * @brief Processes E2 Setup Failure sent by RIC * * @details * - * Function : FreeE2NodeConfigUpdate + * Function : procE2SetupFailure * - * Functionality: - * - freeing the memory allocated for E2nodeConfigurationUpdate + * Functionality: Processes E2 Setup failure sent by RIC * - * @params[in] E2AP_PDU_t *e2apMsg + * @params[in] E2AP_PDU_t ASN decoded E2AP message * @return ROK - success * RFAILED - failure * * ****************************************************************/ -void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg) +void procE2SetupFailure(E2AP_PDU_t *e2apMsg) { - uint8_t arrIdx =0; - E2nodeConfigurationUpdate_t *e2NodeConfigUpdate; + uint8_t arrIdx =0, transId =0, timerValue=0; + E2setupFailure_t *e2SetupFailure; - if(e2apMsg != NULLP) + DU_LOG("\nINFO --> E2AP : E2 Setup failure received"); + e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure; + + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) { - if(e2apMsg->choice.initiatingMessage != NULLP) + switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id) { - e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate; - if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP) + case ProtocolIE_IDE2_id_TransactionID: { - for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++) + transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID; + if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\ + (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode)) { - DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t)); + memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo)); } - DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size); + else + { + DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId); + return ; + } + break; } - DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); + case ProtocolIE_IDE2_id_TimeToWaitE2: + { + timerValue = covertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2); + if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE) + { + duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue); + } + else + { + DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running"); + return; + } + break; + } } - DU_FREE(e2apMsg, sizeof(E2AP_PDU_t)); } -} -/******************************************************************* + freeAperDecodingOfE2SetupFailure(e2SetupFailure); +} +/****************************************************************** * - * @brief Buld and send the E2 node config update msg + * @brief Deallocation of memory allocated bu aper decoder for RIC service Query * * @details * - * Function : BuildAndSendE2NodeConfigUpdate + * Function : freeAperDecodingOfRicServiceQuery * - * Functionality: - * - Buld and send the E2 node config update msg + * Functionality: Deallocation of memory allocated bu aper decoder for RIC + * service Query * - * @params[in] - * @return ROK - success - * RFAILED - failure + * @params[in] RICserviceQuery_t *ricServiceQuery; + * @return void * * ****************************************************************/ -uint8_t BuildAndSendE2NodeConfigUpdate() +void freeAperDecodingOfRicServiceQuery(RICserviceQuery_t *ricServiceQuery) { - uint8_t arrIdx = 0,elementCnt = 1; - uint8_t ret = ROK; - E2AP_PDU_t *e2apMsg = NULLP; - E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP; - asn_enc_rval_t encRetVal; /* Encoder return value */ + uint8_t arrIdx,ranFuncIdx; + RANfunctionsID_List_t *ranFuncAddedList; - DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n"); - do + if(ricServiceQuery) { - DU_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; - DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); - if(e2apMsg->choice.initiatingMessage == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); - DU_FREE(e2apMsg, sizeof(E2AP_PDU_t)); - return RFAILED; - } - e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; - e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate; - e2apMsg->choice.initiatingMessage->value.present = \ - InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate; - e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate; - - e2NodeConfigUpdate->protocolIEs.list.count = elementCnt; - e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*); - /* Initialize the Ric Indication members */ - DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, \ - e2NodeConfigUpdate->protocolIEs.list.size); - if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP) - { - DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed"); - break; - } - - for(arrIdx =0; arrIdxprotocolIEs.list.array) { - DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t)); - if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP) + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) { - - DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed"); - break; + if(ricServiceQuery->protocolIEs.list.array[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++) + { + free(ranFuncAddedList->list.array[ranFuncIdx]); + } + free(ranFuncAddedList->list.array);; + } + break; + } + default: + break; + } + free(ricServiceQuery->protocolIEs.list.array[arrIdx]); + } } + free(ricServiceQuery->protocolIEs.list.array); } + } +} +/******************************************************************* + * + * @brief Build RanFunction Delete List + * + * @details + * + * Function : BuildRanFunctionDeleteList + * + * Functionality: Build RanFunction Delete List + * + * @params[in] + * RANfunctionsID List + * Count of the RAN function + * Received RAN function list + * + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ - arrIdx = 0; - /* TransactionID */ - e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; - e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; - e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID; - e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID; - - - /* Prints the Msg formed */ - xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg); +uint8_t BuildRanFunctionDeleteList(RANfunctionsID_List_t *deleteList, uint8_t count, RanFuncInfo *recvdRanFunc) +{ + uint8_t ranFuncIdx=0; + RANfunctionID_ItemIEs_t *delRanFuncItem; - 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) + if(count) + { + deleteList->list.count = count; + deleteList->list.size = deleteList->list.count * sizeof(RANfunctionID_ItemIEs_t*); + DU_ALLOC(deleteList->list.array, deleteList->list.size); + if(deleteList->list.array == NULLP) { - DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\ - encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); - break; + DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__); + return RFAILED; } - else + for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++) { - DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n"); -#ifdef DEBUG_ASN_PRINT - for(int i=0; i< encBufSize; i++) + DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t)); + if(deleteList->list.array[ranFuncIdx] == NULLP) { - printf("%x",encBuf[i]); + DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__); + return RFAILED; } -#endif - } - if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize)) - { - DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed"); - return RFAILED; - } + delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx]; + delRanFuncItem->id = ProtocolIE_IDE2_id_RANfunctionID_Item; + delRanFuncItem->criticality = CriticalityE2_ignore; + delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionID = recvdRanFunc[ranFuncIdx].id; + delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionRevision = recvdRanFunc[ranFuncIdx].revisionCounter; - break; - }while(true); - - FreeE2NodeConfigUpdate(e2apMsg); - return ret; + } + } + return ROK; } - /******************************************************************* * - * @brief Deallocate the memory allocated for E2ResetRequest msg + * @brief De Allocate Ric Service Update message * * @details * - * Function : FreeE2ResetRequest + * Function : FreeRicServiceUpdate * - * Functionality: - * - freeing the memory allocated for E2ResetRequest + * Functionality: De-Allocating Ric Service Update message * * @params[in] E2AP_PDU_t *e2apMsg - * @return ROK - success - * RFAILED - failure + + * @return void * * ****************************************************************/ -void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg) + +void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg) { - uint8_t ieIdx =0; - ResetRequestE2_t *resetReq = NULLP; + uint8_t arrIdx = 0; + uint8_t ranFuncAddListIdx=0, ranFuncDelIdx=0; + RICserviceUpdate_t *ricServiceUpdate; + RANfunctions_List_t *ranFunctionsList; + RANfunction_ItemIEs_t *ranFuncItemIe; + RANfunction_Item_t *ranFunItem; + RANfunctionsID_List_t *deleteList; + /* De-allocating Memory */ if(e2apMsg != NULLP) { if(e2apMsg->choice.initiatingMessage != NULLP) { - resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2; - if(resetReq->protocolIEs.list.array) + ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate; + if(ricServiceUpdate->protocolIEs.list.array != NULLP) { - for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++) + for(arrIdx = 0; arrIdx < ricServiceUpdate->protocolIEs.list.count; arrIdx++) { - DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t)); + if(ricServiceUpdate->protocolIEs.list.array[arrIdx] != NULLP) + { + switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id) + { + case ProtocolIE_IDE2_id_TransactionID: + break; + + case ProtocolIE_IDE2_id_RANfunctionsAdded: + case ProtocolIE_IDE2_id_RANfunctionsModified: + { + ranFunctionsList = &(ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List); + if(ranFunctionsList->list.array) + { + for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++) + { + if(ranFunctionsList->list.array[ranFuncAddListIdx]) + { + ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx]; + ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item; + DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size); + DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size); + DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t)); + } + } + DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size); + } + break; + } + case ProtocolIE_IDE2_id_RANfunctionsDeleted: + { + deleteList= &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List; + if(deleteList->list.array) + { + for(ranFuncDelIdx = 0; ranFuncDelIdx< deleteList->list.count; ranFuncDelIdx++) + { + DU_FREE(deleteList->list.array[ranFuncDelIdx], sizeof(RANfunctionID_ItemIEs_t)); + } + DU_FREE(deleteList->list.array, deleteList->list.size); + + } + break; + } + default: + DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\ + (ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)); + break; + } + DU_FREE(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t)); + } } - DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size); + DU_FREE(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size); } DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); } @@ -1641,131 +3310,149 @@ void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg) /******************************************************************* * - * @brief Build and send the E2 reset request msg + * @brief Builds and Send the RicServiceUpdateuest * * @details * - * Function : BuildAndSendE2ResetRequest + * Function : BuildAndSendRicServiceUpdate * - * Functionality: - * - Buld and send the E2 reset request msg to RIC + * Functionality:Fills the RicServiceUpdateuest * - * @params[in] * @return ROK - success * RFAILED - failure * - * ****************************************************************/ -uint8_t BuildAndSendE2ResetRequest(E2CauseType failureType, E2Cause failureCause) + ******************************************************************/ + +uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate) { - uint8_t ieIdx = 0, elementCnt = 0, transId = 0; - uint8_t ret = RFAILED; + uint8_t arrIdx = 0, elementCnt=0; + uint8_t transId = 0, ret = RFAILED; + bool memAllocFailed =false; E2AP_PDU_t *e2apMsg = NULLP; - ResetRequestE2_t *resetReq = NULLP; + RICserviceUpdate_t *ricServiceUpdate = NULLP; asn_enc_rval_t encRetVal; /* Encoder return value */ - DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n"); - + DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n"); do { DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t)); if(e2apMsg == NULLP) { - DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed"); + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); break; } - e2apMsg->present = E2AP_PDU_PR_initiatingMessage; DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t)); if(e2apMsg->choice.initiatingMessage == NULLP) { - DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage"); + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); break; } - - e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset; e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject; - e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2; - resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2; - - elementCnt = 2; - resetReq->protocolIEs.list.count = elementCnt; - resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *); + e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceUpdate; + e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceUpdate; + ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate; + + /* For TransId IE, set elementCnt to 1. + If there is any item in the RAN function add list, RAN function modification list, or RAN function delete list, increment the elementCnt.*/ + + elementCnt =1; + if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded) + elementCnt++; + if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified) + elementCnt++; + if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted) + elementCnt++; + + ricServiceUpdate->protocolIEs.list.count = elementCnt; + ricServiceUpdate->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdate_IEs_t*); - DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size); - if(!resetReq->protocolIEs.list.array) + /* Initialize the E2Setup members */ + DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size); + if(ricServiceUpdate->protocolIEs.list.array == NULLP) { - DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \ - Reset Request IE array"); + DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements"); break; } - - for(ieIdx = 0; ieIdx < elementCnt; ieIdx++) + + for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++) { - DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t)); - if(!resetReq->protocolIEs.list.array[ieIdx]) + DU_ALLOC(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t)); + if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP) { - DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \ - Reset Request IE array element"); + memAllocFailed = true; + DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx); break; } } - - /* In case of failure */ - if(ieIdx < elementCnt) + if(memAllocFailed == true) break; - ieIdx = 0; - resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID; - resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject; - resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID; - transId = assignTransactionId(); - resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId; + arrIdx = 0; - ieIdx++; - resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2; - resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore; - resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2; - resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present = failureType; - switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present) + /* TransactionID */ + ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID; + if(serviceUpdate.dir == E2_NODE_INITIATED) + transId = assignTransactionId(); + else + transId = serviceUpdate.transId; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId; + + if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded) { - case CauseE2_PR_NOTHING: - break; - case CauseE2_PR_ricRequest: - resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest = failureCause; - break; - case CauseE2_PR_ricService: - resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService = failureCause; - break; - case CauseE2_PR_e2Node: - resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node = failureCause; - break; - case CauseE2_PR_transport: - resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport = failureCause; - break; - case CauseE2_PR_protocol: - resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol = failureCause; + arrIdx++; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List; + if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,\ + e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded, serviceUpdate.recvRanFuncList.ranFunToBeAdded) !=ROK) + { break; - case CauseE2_PR_misc: - resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc = failureCause; + } + } + + if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified) + { + arrIdx++; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsModified; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List; + if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List, + e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeModified, serviceUpdate.recvRanFuncList.ranFunToBeModified) !=ROK) + { break; + } } + if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted) + { + arrIdx++; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsDeleted; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject; + ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctionsID_List; + if(BuildRanFunctionDeleteList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List,\ + serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted, serviceUpdate.recvRanFuncList.ranFunToBeDeleted) != ROK) + { + break; + } + } /* 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); + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf); if(encRetVal.encoded == ENCODE_FAIL) { - DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\ + DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); break; } else { - DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n"); + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n"); #ifdef DEBUG_ASN_PRINT for(int i=0; i< encBufSize; i++) { @@ -1778,215 +3465,375 @@ uint8_t BuildAndSendE2ResetRequest(E2CauseType failureType, E2Cause failureCause DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed"); break; } - - /* In case the message is sent successfully, store the transaction info to - * be used when response is received */ - duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId = transId; - duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode; - ret = ROK; break; }while(true); - - /* Free all memory */ - FreeE2ResetRequest(e2apMsg); + + if(ret == ROK) + { + if(serviceUpdate.dir == E2_NODE_INITIATED) + { + duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId; + duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode; + } + else + { + duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId = transId; + duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode; + } + duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.dir = serviceUpdate.dir; + duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.transId =transId; + memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.recvRanFuncList, &serviceUpdate.recvRanFuncList, sizeof(E2TmpRanFunList)); + } + FreeRicServiceUpdate(e2apMsg); return ret; } +/****************************************************************** + * + * @brief Processes RIC service Query sent by RIC + * + * @details + * + * Function : procRicServiceQuery + * + * Functionality: Processes RIC service Query sent by RIC + * + * @params[in] E2AP_PDU_t ASN decoded E2AP message + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ -/******************************************************************* +void procRicServiceQuery(E2AP_PDU_t *e2apMsg) +{ + ConfigType action; + uint16_t arrIdx =0, ranFuncIdx=0,tmpIdx=0; + uint16_t id,revisionCcounter; + bool tmpArray[MAX_RAN_FUNCTION] = {false}; + RICserviceQuery_t *ricServiceQuery=NULL; + RicServiceUpdate ricUpdate; + RANfunctionID_ItemIEs_t *ranFuncAddedItemIe; + RANfunctionsID_List_t *ranFuncAddedList; + + DU_LOG("\nINFO --> E2AP : RIC Service Query received"); + memset(&ricUpdate, 0, sizeof(RicServiceUpdate)); + ricUpdate.dir = RIC_INITIATED; + ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery; + + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + { + switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id) + { + /* TODO completing in next patch/gerrit */ + case ProtocolIE_IDE2_id_TransactionID: + { + ricUpdate.transId = ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID; + break; + } + + 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++) + { + if(ranFuncAddedList->list.array[ranFuncIdx]) + { + /* Using the RAN function Id, identify the RAN function to be modified or deleted. */ + + ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx]; + id = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID; + revisionCcounter = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision; + + if((id != duCb.e2apDb.ranFunction[id-1].id)) + { + action = CONFIG_DEL; + } + else if((id == duCb.e2apDb.ranFunction[id-1].id)&&(revisionCcounter!=duCb.e2apDb.ranFunction[id-1].revisionCounter)) + { + action = CONFIG_MOD; + } + + if(action == CONFIG_DEL) + { + ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].id = id; + ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].revisionCounter = revisionCcounter; + ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted++; + } + else if(action == CONFIG_MOD) + { + ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].id = id; + ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].revisionCounter = revisionCcounter; + ricUpdate.recvRanFuncList.numOfRanFunToBeModified++; + } + + /* If any ID is set to true, it means that the ID has been used in either modification or deletion list. + * Else we will add the IDs into the added list */ + tmpArray[id-1] = true; + } + } + } + break; + } + } + } + + /* Traversing the whole RAN function list in ducb to check if any new Ran function ids have been added. */ + for(arrIdx =0; arrIdx0)&&(!tmpArray[arrIdx])) + { + ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[arrIdx].id; + ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[arrIdx].revisionCounter; + ricUpdate.recvRanFuncList.numOfRanFunToBeAdded++; + } + } + + if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message"); + } + + freeAperDecodingOfRicServiceQuery(ricServiceQuery); +} + +/****************************************************************** * - * @brief Deallocate the memory allocated for Reset Response msg + * @brief Deallocation of memory allocated by aper decoder for + * RIC service update ack * * @details * - * Function : freeAperDecodingOfE2ResetRsp + * Function : freeAperDecodingOfRicServiceUpdateAck * - * Functionality: - * - freeing the memory allocated for Reset response + * Functionality: Deallocation of memory allocated by aper decoder + * for RIC service update ack * - * @params[in] ResetResponseE2_t *resetResponse + * @params[in] RICserviceUpdateAck_t *ricServiceAck; * @return void * * ****************************************************************/ -void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse) + +void freeAperDecodingOfRicServiceUpdateAck(RICserviceUpdateAcknowledge_t *ricServiceAck) { - uint8_t ieIdx; + uint8_t arrIdx=0,ranFuncIdx=0; + RANfunctionsID_List_t *ranFuncAddedList=NULL; - if(resetResponse) + if(ricServiceAck) { - if(resetResponse->protocolIEs.list.array) + if(ricServiceAck->protocolIEs.list.array) { - for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++) + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) { - if(resetResponse->protocolIEs.list.array[ieIdx]) + if(ricServiceAck->protocolIEs.list.array[arrIdx]) { - switch(resetResponse->protocolIEs.list.array[ieIdx]->id) + switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id) { - case ProtocolIE_IDE2_id_TransactionID: + case ProtocolIE_IDE2_id_RANfunctionsAccepted: + { + ranFuncAddedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List; + if(ranFuncAddedList->list.array) + { + for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) + { + free(ranFuncAddedList->list.array[ranFuncIdx]); + } + free(ranFuncAddedList->list.array); + } break; - - case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2: + } + default: break; } - free(resetResponse->protocolIEs.list.array[ieIdx]); + free(ricServiceAck->protocolIEs.list.array[arrIdx]); } } - free(resetResponse->protocolIEs.list.array); + free(ricServiceAck->protocolIEs.list.array); } } } /****************************************************************** * - * @brief Processes E2 Reset Response sent by RIC + * @brief Processes RIC service update ack sent by RIC * * @details * - * Function : procResetResponse + * Function : procRicServiceUpdateAck * - * Functionality: Processes E2 Reset Response sent by RIC + * Functionality: Processes RIC service update ack sent by RIC * * @params[in] E2AP_PDU_t ASN decoded E2AP message * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t procResetResponse(E2AP_PDU_t *e2apMsg) -{ - uint8_t ieIdx =0, transId; - ResetResponseE2_t *resetResponse; - DU_LOG("\nINFO --> E2AP : E2 Reset Response received"); - resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;; - - for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++) +void procRicServiceUpdateAck(E2AP_PDU_t *e2apMsg) +{ + uint8_t arrIdx =0, transId =0; + uint16_t id =0, tmpIdx=0, ranFuncIdx=0; + RicServiceUpdate serviceUpdate; + RANfunctionsIDcause_List_t *rejectedList=NULL; + RICserviceUpdateAcknowledge_t *ricServiceAck=NULL; + RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL; + + DU_LOG("\nINFO --> E2AP : RIC service update ack received"); + memset(&serviceUpdate, 0, sizeof(RicServiceUpdate)); + ricServiceAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge; + + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) { - switch(resetResponse->protocolIEs.list.array[ieIdx]->id) + switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id) { case ProtocolIE_IDE2_id_TransactionID: - transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID; - if((duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId == transId) && \ - (duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode)) - memset(&duCb.e2apDb.e2TransInfo.onGoingTransaction[transId], 0, sizeof(E2TransInfo)); + { + transId = ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID; + if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\ + (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode)) + { + memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo)); + } + else if((duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId == transId) &&\ + (duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode)) + { + memset(&duCb.e2apDb.e2TransInfo.ricInitTransaction[transId], 0, sizeof(E2TransInfo)); + } else { DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId); - return RFAILED; + return ; } break; - case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2: - /* As per ORAN WG3 E2AP spec v3.0, section 9.2.2 - Criticality Diagnostics IE is sent by Near-RT RIC when parts of a received message i.e. - Reset Request in this case, have not been comprehended or were missing, or if the message - contained logical errors. - - Processing of this ID should be implemented when negative call flows are to be supported. - */ + } + + case ProtocolIE_IDE2_id_RANfunctionsAccepted: break; - default: - DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld", - resetResponse->protocolIEs.list.array[ieIdx]->id); + + case ProtocolIE_IDE2_id_RANfunctionsRejected: + { + rejectedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List; + if(rejectedList->list.array) + { + for(ranFuncIdx=0;ranFuncIdxlist.count; ranFuncIdx++) + { + ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)rejectedList->list.array[ranFuncIdx]; + id = ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID; + tmpIdx= serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded; + serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[id-1].id; + serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[id-1].revisionCounter; + serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded++; + } + } break; + } + } } - freeAperDecodingOfE2ResetRsp(resetResponse); - return ROK; + if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded) + { + serviceUpdate.dir = E2_NODE_INITIATED; + BuildAndSendRicServiceUpdate(serviceUpdate); + } + freeAperDecodingOfRicServiceUpdateAck(ricServiceAck); } /****************************************************************** * - * @brief Deallocation of memory allocated bu aper decoder for e2 setup Failure + * @brief Deallocation of memory allocated by aper decoder for + * RIC service update failure * * @details * - * Function : freeAperDecodingOfE2SetupFailure + * Function : freeAperDecodingOfRicServiceUpdateFailure * - * Functionality: Deallocation of memory allocated bu aper decoder for e2 - * setup Failure + * Functionality: Deallocation of memory allocated by aper decoder + * for RIC service update failure * - * @params[in] E2setupFailure_t *e2SetupFailure; + * @params[in] RICserviceUpdateFailure_t *ricServiceFailure; * @return void * * ****************************************************************/ -void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure) + +void freeAperDecodingOfRicServiceUpdateFailure(RICserviceUpdateFailure_t *ricServiceFailure) { - uint8_t arrIdx; + uint8_t arrIdx=0; - if(e2SetupFailure) + if(ricServiceFailure) { - if(e2SetupFailure->protocolIEs.list.array) + if(ricServiceFailure->protocolIEs.list.array) { - for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) { - if(e2SetupFailure->protocolIEs.list.array[arrIdx]) + if(ricServiceFailure->protocolIEs.list.array[arrIdx]) { - free(e2SetupFailure->protocolIEs.list.array[arrIdx]); + free(ricServiceFailure->protocolIEs.list.array[arrIdx]); } } - free(e2SetupFailure->protocolIEs.list.array); + free(ricServiceFailure->protocolIEs.list.array); } } } + /****************************************************************** * - * @brief Processes E2 Setup Failure sent by RIC + * @brief Processes RIC service update failure sent by RIC * * @details * - * Function : procE2SetupFailure + * Function : procRicServiceUpdateFailure * - * Functionality: Processes E2 Setup failure sent by RIC + * Functionality: Processes RIC service update failure sent by RIC * * @params[in] E2AP_PDU_t ASN decoded E2AP message * @return ROK - success * RFAILED - failure * * ****************************************************************/ -void procE2SetupFailure(E2AP_PDU_t *e2apMsg) + +void procRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg) { - uint8_t arrIdx =0, transId =0, timerValue=0; - E2setupFailure_t *e2SetupFailure; + uint8_t arrIdx =0, timerValue=0; + RICserviceUpdateFailure_t *ricServiceFailure=NULL; - DU_LOG("\nINFO --> E2AP : E2 Setup failure received"); - e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure; + DU_LOG("\nINFO --> E2AP : RIC service update failure received"); + ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure; - for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) + for(arrIdx=0; arrIdxprotocolIEs.list.count; arrIdx++) { - switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id) + switch(ricServiceFailure->protocolIEs.list.array[arrIdx]->id) { case ProtocolIE_IDE2_id_TransactionID: - { - transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID; - if((duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId == transId) &&\ - (duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode)) - memset(&duCb.e2apDb.e2TransInfo.onGoingTransaction[transId], 0, sizeof(E2TransInfo)); - else { - DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId); - return ; + break; } - break; - } case ProtocolIE_IDE2_id_TimeToWaitE2: { - timerValue = covertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2); - if((duChkTmr((PTR)&(duCb.e2apDb), EVENT_E2_SETUP_TMR)) == FALSE) + timerValue = covertE2WaitTimerEnumToValue(ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2); + if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR)) == FALSE) { - duStartTmr((PTR)&(duCb.e2apDb), EVENT_E2_SETUP_TMR, timerValue); + duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR, timerValue); } else { - DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running"); + DU_LOG("\nERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running"); return; } break; } + case ProtocolIE_IDE2_id_CauseE2: + { + break; + } } } - freeAperDecodingOfE2SetupFailure(e2SetupFailure); + freeAperDecodingOfRicServiceUpdateFailure(ricServiceFailure); } + /******************************************************************* * * @brief Handles received E2AP message and sends back response @@ -2066,6 +3913,11 @@ void E2APMsgHdlr(Buffer *mBuf) procE2SetupFailure(e2apMsg); break; } + case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure: + { + procRicServiceUpdateFailure(e2apMsg); + break; + } default: { DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\ @@ -2097,6 +3949,13 @@ void E2APMsgHdlr(Buffer *mBuf) procResetResponse(e2apMsg); break; } + case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge: + { + procRicServiceUpdateAck(e2apMsg); + break; + } + + default: { DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\ @@ -2117,6 +3976,11 @@ void E2APMsgHdlr(Buffer *mBuf) procRicSubsReq(e2apMsg); break; } + case InitiatingMessageE2__value_PR_RICserviceQuery: + { + procRicServiceQuery(e2apMsg); + break; + } default: { DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\