#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"
/*******************************************************************
*
{
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);
{
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);
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;
}
}
return node;
}
+
/*******************************************************************
*
* @brief Builds E2 node config addition list
}
+/*******************************************************************
+ *
+ * @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;eventTriggerIdx<eventTriggerStyle->list.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;reportStyleIdx<ricReportStyle->list.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; measInfoIdx<ricReportStyle->list.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;styleIdx<ricReportStyle->list.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; measInfoIdx<measInfo->list.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;styleIdx<ricEventTriggerStyle->list.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 add list
+ *
+ * @details
+ *
+ * Function : BuildRanFunctionAddList
+ *
+ * Functionality: Building RAN addition addition list
+ *
+ * @params[in] RANfunctions_List_t *RANfunctions_List
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList)
+{
+ asn_enc_rval_t encRetVal;
+ RanFunction *ranFuncDb;
+ RANfunction_Name_t *ranFuncName;
+ uint8_t ranFuncIdx;
+ RANfunction_ItemIEs_t *ranFuncItemIe;
+ RANfunction_Item_t *ranFuncItem;
+ E2SM_KPM_RANfunction_Description_t *ranFuncDefinition;
+
+ ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
+ 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;
+ }
+
+ 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;
+ ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
+ ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
+ /* 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__);
+ return RFAILED;
+ }
+ 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__);
+ return RFAILED;
+ }
+
+ /* 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__);
+ return RFAILED;
+ }
+ 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__);
+ return RFAILED;
+ }
+ memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
+
+ /* RAN function 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__);
+ return RFAILED;
+ }
+ 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__);
+ return RFAILED;
+ }
+
+ if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
+ {
+ DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
+ return RFAILED;
+ }
+
+ /* 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__);
+ return RFAILED;
+ }
+ if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
+ return RFAILED;
+ }
+
+ /* 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]);
+ }
+
+ }
+ ranFuncItem->ranFunctionDefinition.size = encBufSize;
+ DU_ALLOC(ranFuncItem->ranFunctionDefinition.buf, encBufSize);
+ if(ranFuncItem->ranFunctionDefinition.buf == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
+ return RFAILED;
+ }
+ memcpy(ranFuncItem->ranFunctionDefinition.buf, &encBuf, encBufSize);
+ }
+ freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
+ return ROK;
+}
+
/*******************************************************************
*
* @brief De Allocate E2 Setup Request Message
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)
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));
}
}
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));
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*);
}
}
+ /* 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))!=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;
}
#include "E2AP-PDU.h"
#include "du_log.h"
#include "E2nodeComponentInterfaceF1.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"
/*******************************************************************
* ****************************************************************/
void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
{
- uint8_t arrIdx = 0;
+ uint8_t arrIdx = 0, e2NodeConfigIdx=0, ranFuncIdx=0;
+ RANfunctionsID_List_t *ranFuncAddedList;
E2setupResponse_t *e2SetupRsp;
-
+ E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe;
+ E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList;
+ E2nodeComponentInterfaceF1_t *f1InterfaceInfo;
+
if(e2apMsg)
{
if(e2apMsg->choice.successfulOutcome)
{
for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
{
+ switch(e2SetupRsp->protocolIEs.list.array[arrIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_RANfunctionsAccepted:
+ {
+ ranFuncAddedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
+ if(ranFuncAddedList->list.array)
+ {
+ for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
+ {
+ if(ranFuncAddedList->list.array[arrIdx])
+ {
+ RIC_FREE(ranFuncAddedList->list.array[arrIdx], sizeof(RANfunction_ItemIEs_t));
+ }
+ }
+ RIC_FREE(ranFuncAddedList->list.array, ranFuncAddedList->list.size);
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
+ {
+ e2NodeConfigAdditionAckList =&e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
+ if(e2NodeConfigAdditionAckList->list.count)
+ {
+ for(e2NodeConfigIdx=0; e2NodeConfigIdx<e2NodeConfigAdditionAckList->list.count; e2NodeConfigIdx++)
+ {
+ e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2NodeConfigIdx];
+ if(e2NodeAddAckItemIe)
+ {
+ f1InterfaceInfo = e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
+ if(f1InterfaceInfo)
+ {
+ RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
+ RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
+ }
+ RIC_FREE(e2NodeAddAckItemIe, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
+ }
+ }
+ RIC_FREE(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
+ }
+ break;
+ }
+ }
RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
}
RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
* @return ROK - success
* RFAILED - failure
* ****************************************************************/
-uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, uint8_t duId)
+
+uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, DuDb *duDb)
{
uint8_t arrIdx = 0;
E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
e2NodeAddAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
e2NodeAddAckItem->criticality = CriticalityE2_reject;
e2NodeAddAckItem->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_E2nodeComponentConfigAdditionAck_Item;
- e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_f1;
+ e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentInterfaceType = duDb->e2NodeComponent.interfaceType;
/* >E2 Node Component ID */
e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
return RFAILED;
}
- e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = duId;
+ e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = duDb->e2NodeComponent.componentId;
/* >E2 Node Component Configuration Acknowledge*/
e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentConfigurationAck.updateOutcome = \
return ROK;
}
+
+/*******************************************************************
+ *
+ * @brief Build RAN function added list
+ *
+ * @details
+ *
+ * Function : BuildRanFunctionAddedList
+ *
+ * Functionality: Build RAN function added list
+ *
+ * @params[in] DuDb *duDb, RANfunctionsID_List_t *ranFuncAddedList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ * ****************************************************************/
+
+uint8_t BuildRanFunctionAddedList(DuDb *duDb, RANfunctionsID_List_t *ranFuncAddedList)
+{
+ uint8_t ranFuncIdx = 0;
+ RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
+
+ ranFuncAddedList->list.count = duDb->numOfRanFunction;
+ ranFuncAddedList->list.size = ranFuncAddedList->list.count*sizeof(RANfunctionID_ItemIEs_t*);
+ RIC_ALLOC(ranFuncAddedList->list.array, ranFuncAddedList->list.size);
+ if(ranFuncAddedList->list.array)
+ {
+ for(ranFuncIdx = 0; ranFuncIdx< ranFuncAddedList->list.count; ranFuncIdx++)
+ {
+ RIC_ALLOC(ranFuncAddedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
+ if(ranFuncAddedList->list.array[ranFuncIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array item");
+ return RFAILED;
+ }
+ ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
+ ranFuncAddedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
+ ranFuncAddedItemIe->criticality= CriticalityE2_ignore;
+ ranFuncAddedItemIe->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item;
+ ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID =duDb->ranFunction[ranFuncIdx].id;
+ ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision=duDb->ranFunction[ranFuncIdx].revisionCounter;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array");
+ return RFAILED;
+ }
+ return ROK;
+}
+
/*******************************************************************
*
* @brief Builds and sends the E2SetupResponse
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendE2SetupRsp(uint32_t duId, uint8_t transId)
+uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId)
{
E2AP_PDU_t *e2apMsg = NULL;
E2setupResponse_t *e2SetupRsp;
SuccessfulOutcomeE2__value_PR_E2setupResponse;
e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
- elementCnt = 3;
+ elementCnt = 4;
e2SetupRsp->protocolIEs.list.count = elementCnt;
e2SetupRsp->protocolIEs.list.size = elementCnt * sizeof(E2setupResponseIEs_t*);
break;
}
+ /* Accepted RAN function Id */
+ idx++;
+ e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
+ e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
+ e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List;
+ if(BuildRanFunctionAddedList(duDb, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List)!=ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
+ break;
+ }
+
/* E2 Node Component Configuration Addition Acknowledge List*/
idx++;
e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List;
- if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->value.choice.E2nodeComponentConfigAdditionAck_List, duId)!=ROK)
+ if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->value.choice.E2nodeComponentConfigAdditionAck_List, duDb)!=ROK)
{
DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
break;
}
}
- if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
+ if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
{
DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
break;
}
FreeE2SetupRsp(e2apMsg);
- BuildAndSendRicSubscriptionReq(duId);
+ BuildAndSendRicSubscriptionReq(duDb->duId);
return ROK;
}
uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
{
- uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0, transId =0;
+ uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0, transId =0, ranFuncIdx;
DuDb *duDb = NULLP;
E2nodeComponentConfigAddition_List_t *e2NodeAddList;
E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
+ RANfunction_ItemIEs_t *ranFuncItemIe;
+ RANfunction_Item_t *ranFunItem;
+ RANfunctions_List_t *ranFunctionsList;
if(e2SetupReq)
{
- if(e2SetupReq->protocolIEs.list.array)
- {
- for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
+ if(e2SetupReq->protocolIEs.list.array)
+ {
+ for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
+ {
+ if(e2SetupReq->protocolIEs.list.array[arrIdx])
{
- if(e2SetupReq->protocolIEs.list.array[arrIdx])
+ switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
{
- switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
- {
- case ProtocolIE_IDE2_id_TransactionID:
+ case ProtocolIE_IDE2_id_TransactionID:
{
transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
break;
}
+ case ProtocolIE_IDE2_id_GlobalE2node_ID:
+ {
+ if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID)
+ {
+ *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0];
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ duDb = &ricCb.duInfo[ricCb.numDu];
+ ricCb.numDu++;
+ }
+ memset(duDb, 0, sizeof(DuDb));
+ duDb->duId = *duId;
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RANfunctionsAdded:
+ {
+ ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
+
+ if(ranFunctionsList->list.array)
+ {
+ for(ranFuncIdx=0;ranFuncIdx<ranFunctionsList->list.count; ranFuncIdx++)
+ {
+ ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
+ ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
+ duDb->ranFunction[duDb->numOfRanFunction].id = ranFunItem->ranFunctionID;
+ duDb->ranFunction[ duDb->numOfRanFunction].revisionCounter = ranFunItem->ranFunctionRevision;
+ duDb->numOfRanFunction++;
+ }
+ }
+ break;
+ }
case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
{
e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
{
e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
- e2nodeComponentInterfaceTypeF1)
+ e2nodeComponentInterfaceTypeF1)
{
- if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
- e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf)
- {
- *duId = e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\
- choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
- SEARCH_DU_DB(duIdx, duId, duDb);
- if(duDb == NULLP)
- {
- duDb = &ricCb.duInfo[ricCb.numDu];
- ricCb.numDu++;
- }
- memset(duDb, 0, sizeof(DuDb));
- duDb->duId = *duId;
-
- if(BuildAndSendE2SetupRsp(*duId, transId) !=ROK)
- {
- DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
- return RFAILED;
- }
- }
+ duDb->e2NodeComponent.interfaceType = F1;
+ duDb->e2NodeComponent.componentId = e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
}
}
}
}
}
}
+ if(BuildAndSendE2SetupRsp(duDb, transId) !=ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
+ return RFAILED;
+ }
return ROK;
}
Code Review / o-du / l2.git / commitdiff