X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_f1ap_msg_hdl.c;h=b30f89d3017f2c4dc9a39af975e5b82a3665e495;hb=5b0a8c1ccec481f354d22c1dff57b35bf72a1622;hp=292b5c7b051121ca4e564976e1e029963ae19c27;hpb=904e86bfdd8b8caacb73b9b7ae40c279e5befb84;p=o-du%2Fl2.git diff --git a/src/du_app/du_f1ap_msg_hdl.c b/src/du_app/du_f1ap_msg_hdl.c index 292b5c7b0..b30f89d30 100644 --- a/src/du_app/du_f1ap_msg_hdl.c +++ b/src/du_app/du_f1ap_msg_hdl.c @@ -18,6 +18,7 @@ /* This file contains F1AP message handler functions */ #include "common_def.h" +#include "du_tmr.h" #include "ckw.h" #include "ckw.x" #include "kwu.h" @@ -33,6 +34,8 @@ #include "du_app_mac_inf.h" #include "du_cfg.h" #include "du_app_rlc_inf.h" +#include "du_e2ap_mgr.h" +#include "du_e2ap_msg_hdl.h" #include "du_mgr_main.h" #include "du_mgr.h" #include "du_utils.h" @@ -160,7 +163,6 @@ #include "UPTransportLayerInformation.h" #include "GTPTunnel.h" #include "SupportedSULFreqBandItem.h" -#include "du_e2ap_msg_hdl.h" #include "du_f1ap_conversions.h" #include "CNUEPagingIdentity.h" #include "PCCH-Config.h" @@ -174,8 +176,15 @@ #include "CFRA-SSB-Resource.h" #include "BWP-UplinkCommon.h" #include "ReconfigurationWithSync.h" +#include "BCCH-DL-SCH-Message.h" #include "du_sys_info_hdl.h" #include "DRX-ConfigRrc.h" +#include "MeasurementTimingConfigurationRrc.h" +#include "MeasurementTimingConfigurationRrc-IEs.h" +#include "MeasTimingList.h" +#include "MeasTiming.h" +#include "Cells-Status-List.h" +#include "Cells-Status-Item.h" #ifdef O1_ENABLE #include "CmInterface.h" @@ -540,6 +549,7 @@ uint8_t fillNrTddInfo(TDD_Info_t *tddInfo) freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\ f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand; + freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt; freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\ supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*); @@ -824,6 +834,186 @@ uint8_t BuildServedPlmn(ServedPLMNs_List_t *srvplmn) } return ROK; } + +/******************************************************************* + * + * @brief Frees Measurement Timing configuration + * + * @details + * + * Function : FreeMeasTimingConf + * + * Functionality: Frees Timing Configuration + * + * @params[in] MeasurementTimingConfigurationRrc_t measTimingConfRrc + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void FreeMeasTimingConf(MeasurementTimingConfigurationRrc_t measTimingConfRrc) +{ + uint8_t measIeIdx = 0; + MeasurementTimingConfigurationRrc_IEs_t *measTimingConfIEs = NULLP; + + if(measTimingConfRrc.criticalExtensions.choice.c1) + { + if(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf) + { + measTimingConfIEs = measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf; + if(measTimingConfIEs->measTiming) + { + if(measTimingConfIEs->measTiming->list.array) + { + for(measIeIdx = 0; measIeIdx < measTimingConfIEs->measTiming->list.count; measIeIdx++) + { + if(measTimingConfIEs->measTiming->list.array[measIeIdx]) + { + DU_FREE(measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming)); + DU_FREE(measTimingConfIEs->measTiming->list.array[measIeIdx], sizeof(MeasTiming_t)); + } + } + DU_FREE(measTimingConfIEs->measTiming->list.array, measTimingConfIEs->measTiming->list.size); + } + DU_FREE(measTimingConfIEs->measTiming, sizeof(MeasTimingList_t)); + } + DU_FREE(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(MeasurementTimingConfigurationRrc_IEs_t)); + } + DU_FREE(measTimingConfRrc.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1)); + } +} + +/******************************************************************* + * + * @brief Builds MEasuerment Timing Configuration + * + * @details + * + * Function : BuildMeasTimingConf + * + * Functionality: Building Measurement Timing Configuration + * + * @params[in] Pointer to octet string to store Measurement timing + * Configuration + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t BuildMeasTimingConf(OCTET_STRING_t *measTimingConf) +{ + uint8_t ret = RFAILED; + uint8_t elementCnt = 0; + uint8_t measIeIdx = 0; + asn_enc_rval_t encRetVal; + MeasurementTimingConfigurationRrc_t measTimingConfRrc; + MeasurementTimingConfigurationRrc_IEs_t *measTimingConfIEs = NULLP; + struct MeasTiming__frequencyAndTiming *freqAndTiming = NULLP; + + while(true) + { + measTimingConfRrc.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1; + DU_ALLOC(measTimingConfRrc.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1)); + if(!measTimingConfRrc.criticalExtensions.choice.c1) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for critical extension choice C1"); + break; + } + measTimingConfRrc.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf; + + DU_ALLOC(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(MeasurementTimingConfigurationRrc_IEs_t)); + if(!measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for measTimingConf"); + break; + } + measTimingConfIEs = measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf; + + DU_ALLOC(measTimingConfIEs->measTiming, sizeof(MeasTimingList_t)); + if(!measTimingConfIEs->measTiming) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList"); + break; + } + + elementCnt = 1; + measTimingConfIEs->measTiming->list.count = elementCnt; + measTimingConfIEs->measTiming->list.size = elementCnt * sizeof(MeasTiming_t *); + DU_ALLOC(measTimingConfIEs->measTiming->list.array, measTimingConfIEs->measTiming->list.size); + if(!measTimingConfIEs->measTiming->list.array) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList array"); + break; + } + + for(measIeIdx = 0; measIeIdx < elementCnt; measIeIdx++) + { + DU_ALLOC(measTimingConfIEs->measTiming->list.array[measIeIdx], sizeof(MeasTiming_t)); + if(!measTimingConfIEs->measTiming->list.array[measIeIdx]) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList array index %d", measIeIdx); + break; + } + } + if(measIeIdx < elementCnt) + { + break; + } + + measIeIdx = 0; + DU_ALLOC(measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming)); + if(!measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for frequencyAndTiming"); + break; + } + freqAndTiming = measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming; + freqAndTiming->carrierFreq = MEAS_TIMING_ARFCN; + freqAndTiming->ssbSubcarrierSpacing = duCfgParam.macCellCfg.ssbCfg.scsCmn; + freqAndTiming->ssb_MeasurementTimingConfiguration.periodicityAndOffset.present = duCfgParam.macCellCfg.ssbCfg.ssbPeriod + 1; + freqAndTiming->ssb_MeasurementTimingConfiguration.periodicityAndOffset.choice.sf20 = duCfgParam.macCellCfg.ssbCfg.ssbScOffset; + freqAndTiming->ssb_MeasurementTimingConfiguration.duration = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfgDuration; + + /* Encode the F1SetupRequest type as APER */ + xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfRrc); + + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = uper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfRrc, PrepFinalEncBuf, encBuf); + + /* Encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> F1AP : Could not encode Measurement Timing Configuration structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for Measurement Timing Configuration \n"); +#ifdef DEBUG_ASN_PRINT + for(measIeIdx=0; measIeIdx< encBufSize; measIeIdx++) + { + printf("%x",encBuf[measIeIdx]); + } +#endif + + measTimingConf->size = encBufSize; + DU_ALLOC(measTimingConf->buf, encBufSize); + if(measTimingConf->buf == NULLP) + { + DU_LOG("\nERROR --> F1AP : Memory allocation failed for MeasurementTimingConfiguration buffer"); + return RFAILED; + } + memcpy(measTimingConf->buf, &encBuf, encBufSize); + + FreeMeasTimingConf(measTimingConfRrc); + + ret = ROK; + break; + } + } + return ret; +} + /******************************************************************* * * @brief Builds Served Cell List @@ -861,19 +1051,19 @@ uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell) for(plmnidx=0; plmnidxlist.array[plmnidx],\ - sizeof(GNB_DU_Served_Cells_ItemIEs_t)); + sizeof(GNB_DU_Served_Cells_ItemIEs_t)); if(duServedCell->list.array[plmnidx] == NULLP) { - return RFAILED; + return RFAILED; } } idx = 0; duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item; duServedCell->list.array[idx]->criticality = Criticality_reject; duServedCell->list.array[idx]->value.present = \ - GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item; + GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item; srvCellItem = \ - &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item; + &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item; /*nRCGI*/ BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI); if(BuildNrcgiret != ROK) @@ -882,42 +1072,36 @@ uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell) } /*nRPCI*/ srvCellItem->served_Cell_Information.nRPCI = \ - duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci; + duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci; - /*fiveGS_TAC*/ + /* fiveGS_TAC */ BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information); if(BuildFiveGSTacret != ROK) { return RFAILED; } - /*Served PLMNs*/ + + /* Served PLMNs */ BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs); if(BuildServedPlmnret !=ROK) { return RFAILED; } - /*nR Mode Info with FDD*/ + + /* nR Mode Info with FDD/TDD */ BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info); if(BuildNrModeret != ROK) { return RFAILED; } + /*Measurement timing Config*/ - srvCellItem->served_Cell_Information.measurementTimingConfiguration.\ - size = sizeof(uint8_t); - DU_ALLOC(srvCellItem->served_Cell_Information.\ - measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size); - if(srvCellItem->served_Cell_Information.\ - measurementTimingConfiguration.buf == NULLP) - { + if(BuildMeasTimingConf(&srvCellItem->served_Cell_Information.measurementTimingConfiguration) != ROK) return RFAILED; - } - srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \ - duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg; /* GNB DU System Information */ DU_ALLOC(srvCellItem->gNB_DU_System_Information, - sizeof(GNB_DU_System_Information_t)); + sizeof(GNB_DU_System_Information_t)); if(!srvCellItem->gNB_DU_System_Information) { return RFAILED; @@ -925,20 +1109,20 @@ uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell) /* MIB */ srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen; DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf, - srvCellItem->gNB_DU_System_Information->mIB_message.size); + srvCellItem->gNB_DU_System_Information->mIB_message.size); if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf) { return RFAILED; } memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \ - srvCellItem->gNB_DU_System_Information->mIB_message.size); + srvCellItem->gNB_DU_System_Information->mIB_message.size); /* SIB1 */ srvCellItem->gNB_DU_System_Information->sIB1_message.size =\ - duCfgParam.srvdCellLst[0].duSysInfo.sib1Len; + duCfgParam.srvdCellLst[0].duSysInfo.sib1Len; DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf, - srvCellItem->gNB_DU_System_Information->sIB1_message.size); + srvCellItem->gNB_DU_System_Information->sIB1_message.size); if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf) { return RFAILED; @@ -946,7 +1130,7 @@ uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell) for(int x=0; xgNB_DU_System_Information->sIB1_message.size; x++) { srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\ - duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x]; + duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x]; } return ROK; } @@ -1214,7 +1398,7 @@ void freeFddNrFreqInfo(FDD_Info_t *fDD) * ****************************************************************/ void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell) { - uint8_t plmnCnt=MAX_PLMN; + uint8_t plmnCnt= 1; uint8_t extensionCnt=IE_EXTENSION_LIST_COUNT; uint8_t plmnIdx=0, sliceIdx=0; GNB_DU_Served_Cells_Item_t *srvCellItem; @@ -1359,50 +1543,136 @@ void FreeF1SetupReq(F1AP_PDU_t *f1apMsg) { if(f1apMsg->choice.initiatingMessage != NULLP) { - f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest; - if(f1SetupReq->protocolIEs.list.array != NULLP) - { - for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++) - { - if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP) - { - switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id) - { - case ProtocolIE_ID_id_TransactionID: - break; - case ProtocolIE_ID_id_gNB_DU_ID: - DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\ - f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size); - break; - case ProtocolIE_ID_id_gNB_DU_Name: - DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\ - strlen((char *)duCfgParam.duName)); - break; - case ProtocolIE_ID_id_gNB_DU_Served_Cells_List: - FreeServedCellList(&f1SetupReq->protocolIEs.list.\ - array[ieIdx]->value.choice.GNB_DU_Served_Cells_List); - break; - case ProtocolIE_ID_id_GNB_DU_RRC_Version: - FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version); - break; - default: - DU_LOG("\nERROR --> Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id); - break; - } - } - } - for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++) - { - DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t)); - } - DU_FREE(f1SetupReq->protocolIEs.list.array,\ - f1SetupReq->protocolIEs.list.size); - } - DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t)); + f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest; + if(f1SetupReq->protocolIEs.list.array != NULLP) + { + for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++) + { + if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP) + { + switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_ID_id_TransactionID: + break; + case ProtocolIE_ID_id_gNB_DU_ID: + DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\ + f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size); + break; + case ProtocolIE_ID_id_gNB_DU_Name: + DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\ + strlen((char *)duCfgParam.duName)); + break; + case ProtocolIE_ID_id_gNB_DU_Served_Cells_List: + FreeServedCellList(&f1SetupReq->protocolIEs.list.\ + array[ieIdx]->value.choice.GNB_DU_Served_Cells_List); + break; + case ProtocolIE_ID_id_GNB_DU_RRC_Version: + FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version); + break; + default: + DU_LOG("\nERROR --> Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id); + break; + } + } + } + for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++) + { + DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t)); + } + DU_FREE(f1SetupReq->protocolIEs.list.array,\ + f1SetupReq->protocolIEs.list.size); + } + DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t)); } DU_FREE(f1apMsg, sizeof(F1AP_PDU_t)); } } + +/******************************************************************* + * + * @brief add or modify E2NodeComponent list + * + * @details + * + * Function : addOrModifyE2NodeComponent + * + * Functionality: add or modify E2NodeComponent list + * + * @parameter uint8_t componentactiontype, bool reqPart, uint8_t bufSize, char *bufString + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t addOrModifyE2NodeComponent(uint8_t action, bool reqPart, uint8_t bufSize, char *bufString) +{ + E2NodeComponent *e2NodeComponentInfo; + CmLList *node = NULLP; + + if(action == E2_NODE_COMPONENT_ADD) + { + if(reqPart == true) + { + DU_ALLOC(e2NodeComponentInfo, sizeof(E2NodeComponent)); + if(!e2NodeComponentInfo) + { + DU_LOG("\nERROR --> F1AP : Memory allocation failed for e2NodeComponentInfo in %s",__func__); + return RFAILED; + } + e2NodeComponentInfo->interfaceType =F1; + e2NodeComponentInfo->componentId=duCfgParam.duId; + e2NodeComponentInfo->componentActionType = action; + e2NodeComponentInfo->reqBufSize = bufSize; + + DU_ALLOC(e2NodeComponentInfo->componentRequestPart, bufSize); + if(e2NodeComponentInfo->componentRequestPart == NULLP) + { + DU_LOG("\nERROR --> F1AP : Memory allocation failed for componentRequestPart"); + DU_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent)); + return RFAILED; + } + memcpy(e2NodeComponentInfo->componentRequestPart, bufString, e2NodeComponentInfo->reqBufSize); + DU_ALLOC(node, sizeof(CmLList)); + if(node) + { + node->node = (PTR) e2NodeComponentInfo; + cmLListAdd2Tail(&duCb.e2apDb.e2NodeComponentList, node); + } + else + { + DU_LOG("\nERROR --> F1AP : Memory allocation failed for e2NodeComponentList node"); + DU_FREE(e2NodeComponentInfo->componentRequestPart, bufSize); + DU_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent)); + return RFAILED; + } + } + else + { + if(duCb.e2apDb.e2NodeComponentList.count) + { + CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node); + while(node) + { + e2NodeComponentInfo = (E2NodeComponent*)node->node; + if((e2NodeComponentInfo->interfaceType == F1) && (e2NodeComponentInfo->componentActionType == action)) + { + e2NodeComponentInfo->rspBufSize = bufSize; + + DU_ALLOC(e2NodeComponentInfo->componentResponsePart, bufSize); + if(e2NodeComponentInfo->componentResponsePart == NULLP) + { + DU_LOG("\nERROR --> F1AP : Memory allocation failed to store the encoding of f1setup rsp"); + return RFAILED; + } + memcpy(e2NodeComponentInfo->componentResponsePart, bufString, e2NodeComponentInfo->rspBufSize); + break; + } + node = node->next; + } + } + } + } + return ROK; +} /******************************************************************* * * @brief Builds and Send the F1SetupRequest @@ -1433,25 +1703,25 @@ uint8_t BuildAndSendF1SetupReq() DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t)); if(f1apMsg == NULLP) { - break; + break; } f1apMsg->present = F1AP_PDU_PR_initiatingMessage; DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t)); if(f1apMsg->choice.initiatingMessage == NULLP) { - break; + break; } f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup; f1apMsg->choice.initiatingMessage->criticality = Criticality_reject; f1apMsg->choice.initiatingMessage->value.present = \ - InitiatingMessage__value_PR_F1SetupRequest; + InitiatingMessage__value_PR_F1SetupRequest; f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest; - elementCnt = 4; + elementCnt = 5; f1SetupReq->protocolIEs.list.count = elementCnt; - f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t ); + f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t *); /* Initialize the F1Setup members */ DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size); @@ -1497,7 +1767,6 @@ uint8_t BuildAndSendF1SetupReq() f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\ duCfgParam.duId; -#if 0 /* DU name IE is of type printableString_t which wireshark is unable to decode. * However this string is decoded successfully on online decoders. * Since this is an optional IE and the value received in it are not @@ -1518,9 +1787,8 @@ uint8_t BuildAndSendF1SetupReq() break; } strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf, - (char*)&duCfgParam.duName); + (char*)duCfgParam.duName); } -#endif /*Served Cell list */ ieIdx++; @@ -1536,7 +1804,6 @@ uint8_t BuildAndSendF1SetupReq() break; } - /*RRC Version*/ ieIdx++; f1SetupReq->protocolIEs.list.array[ieIdx]->id = \ @@ -1574,17 +1841,10 @@ uint8_t BuildAndSendF1SetupReq() printf("%x",encBuf[ieIdx]); } #endif + - duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize; - DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize); - if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP) - { - DU_LOG("\nERROR --> F1AP : Memory allocation failed to store the encoding of f1setup req"); - return RFAILED; - } - memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize); } - + addOrModifyE2NodeComponent(E2_NODE_COMPONENT_ADD, true, encBufSize, encBuf); /* Sending msg */ if(sendF1APMsg() != ROK) { @@ -1705,7 +1965,7 @@ void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem) } } DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\ - modifyItem->served_Cell_Information.measurementTimingConfiguration.size); + modifyItem->served_Cell_Information.measurementTimingConfiguration.size); } /******************************************************************* @@ -1726,12 +1986,13 @@ void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem) * ****************************************************************/ void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg) { - uint8_t ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0; + uint8_t idx=0,ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0; GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP; Served_Cells_To_Modify_List_t *cellsToModify=NULLP; Served_Cells_To_Delete_List_t *cellsToDelete=NULLP; Served_Cells_To_Delete_Item_t *deleteItem = NULLP; Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP; + Cells_Status_ItemIEs_t *cellStatusItemIE; if(f1apDuCfg != NULLP) { @@ -1799,6 +2060,18 @@ void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg) duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size); break; } + case ProtocolIE_ID_id_Cells_Status_List: + { + for(idx = 0; idx < duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.count; idx++) + { + cellStatusItemIE = (Cells_Status_ItemIEs_t *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.array[idx]; + DU_FREE(cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.nRCellIdentity.buf, cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.nRCellIdentity.size); + DU_FREE(cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.pLMN_Identity.buf, cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.pLMN_Identity.size); + DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.array[idx],sizeof(Cells_Status_ItemIEs_t)); + } + DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.array,\ + duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.size); + } } DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\ sizeof(GNBDUConfigurationUpdateIEs_t)); @@ -2142,15 +2415,8 @@ uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo) #endif /*Measurement timing Config*/ - srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t); - DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\ - buf,srvCellInfo->measurementTimingConfiguration.size); - if(srvCellInfo->measurementTimingConfiguration.buf == NULLP) - { + if(BuildMeasTimingConf(&srvCellInfo->measurementTimingConfiguration) != ROK) return RFAILED; - } - srvCellInfo->measurementTimingConfiguration.\ - buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg; return ROK; } @@ -2298,6 +2564,7 @@ uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity); return ROK; } + /******************************************************************* * * @brief Builds ServCellToDeleteList @@ -2349,6 +2616,56 @@ uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete) return ROK; } +/******************************************************************* + * + * @brief Builds CellsStatusList + * + * @details + * + * Function : buildCellsStatusList + * + * Functionality: Builds the Cell Status List + * + * @params[in] Pointer to Cells_Status_List_t * + * + * @return ROK - success + * RFAILED - failure + * + *****************************************************************/ +uint8_t buildCellsStatusList(Cells_Status_List_t *cellStatusList) +{ + uint8_t elementCnt = 0, idx = 0, ret = ROK; + Cells_Status_ItemIEs_t *cellStatusItemIE; + + elementCnt = 1; + cellStatusList->list.count = elementCnt; + cellStatusList->list.size = elementCnt * sizeof(Cells_Status_ItemIEs_t *); + DU_ALLOC(cellStatusList->list.array, cellStatusList->list.size); + + for(idx = 0; idx < elementCnt; idx++) + { + DU_ALLOC(cellStatusList->list.array[idx], sizeof(Cells_Status_ItemIEs_t)); + if(!cellStatusList->list.array[idx]) + { + DU_LOG("ERROR --> F1AP: buildCellsStatusList() memory allocation failure"); + return RFAILED; + } + } + idx = 0; + cellStatusItemIE = (Cells_Status_ItemIEs_t *)cellStatusList->list.array[idx]; + cellStatusItemIE->id = ProtocolIE_ID_id_Cells_Status_Item; + cellStatusItemIE->criticality = Criticality_reject; + cellStatusItemIE->value.present = Cells_Status_ItemIEs__value_PR_Cells_Status_Item; + ret = BuildNrcgi(&cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI); + if(ret == RFAILED) + { + DU_LOG("ERROR --> F1AP: buildCellsStatusList() NRCGI failed"); + return RFAILED; + } + cellStatusItemIE->value.choice.Cells_Status_Item.service_status.service_state = Service_State_in_service; + return ROK; +} + /******************************************************************* * * @brief Builds and sends the DUConfigUpdate @@ -2404,7 +2721,7 @@ uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction) InitiatingMessage__value_PR_GNBDUConfigurationUpdate; duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\ choice.GNBDUConfigurationUpdate; - elementCnt = 3; + elementCnt = 4; duCfgUpdate->protocolIEs.list.count = elementCnt; duCfgUpdate->protocolIEs.list.size = \ elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*); @@ -2471,7 +2788,21 @@ uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction) } } - // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE + // TODO :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE + + /*Cell Status List*/ + ieIdx++; + duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cells_Status_List; + duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject; + duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \ + GNBDUConfigurationUpdateIEs__value_PR_Cells_Status_List; + ret = buildCellsStatusList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List); + if(ret == RFAILED) + { + DU_LOG("ERROR --> DU APP : BuildAndSendDUConfigUpdate(): Cell Status List building failed"); + break; + } + /*GNB DU ID */ ieIdx++; duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID; @@ -2606,7 +2937,7 @@ uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb *ueCb, uint8_t lcId, \ while(true) { - DU_LOG("\n INFO --> F1AP : Building UL RRC Message Transfer Message\n"); + DU_LOG("\nINFO --> F1AP : Building UL RRC Message Transfer Message\n"); DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t)); if(f1apMsg == NULLP) @@ -2707,7 +3038,7 @@ uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb *ueCb, uint8_t lcId, \ } else { - DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n"); + DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n"); #ifdef DEBUG_ASN_PRINT for(int i=0; i< encBufSize; i++) { @@ -3036,7 +3367,8 @@ uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig) /* Fill default AM UL configuration if input pointer to DU database is NULL */ if(amCfg == NULLP) { - *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN; + + *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN_12BIT; /*As per Spec 38.331, "Network configures only value size12 in SN-FieldLengthAM for SRB"*/ rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit = T_POLL_RETRANSMIT; rlcConfig->choice.am->ul_AM_RLC.pollPDU = POLL_PDU; rlcConfig->choice.am->ul_AM_RLC.pollByte = POLL_BYTE; @@ -3063,7 +3395,7 @@ uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig) /* Fill default AM DL configuration if input pointer to DU database is NULL */ if(amCfg == NULLP) { - *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN; + *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN_12BIT; /*As per Spec 38.331, "Network configures only value size12 in SN-FieldLengthAM for SRB"*/ rlcConfig->choice.am->dl_AM_RLC.t_Reassembly = T_REASSEMBLY; rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit = T_STATUS_PROHIBHIT; } @@ -6717,7 +7049,7 @@ uint8_t BuildSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon) convertSsbPeriodicityValueToEnum(duCfgParam.sib1Params.srvCellCfgCommSib.ssbPrdServingCell); /* DMRS Type A position */ - spCellConfigCommon->dmrs_TypeA_Position = convertDmrsTypeAPosValueToEnum(duCfgParam.macCellCfg.dmrsTypeAPos); + spCellConfigCommon->dmrs_TypeA_Position = convertDmrsTypeAPosValueToEnum(duCfgParam.macCellCfg.ssbCfg.dmrsTypeAPos); /* SSB subcarrier spacing */ DU_ALLOC(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t)); @@ -13081,7 +13413,7 @@ uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb) * * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t, * DRBs_ToBeModified_Item_t , lcId, DuLcCfg pointer, - * RlcBearerCfg , UpTnlCfg, RlcUeCfg + * RlcBearerCfg , UpTnlCfg, DuRlcUeCfg * @return void * * ****************************************************************/ @@ -15291,19 +15623,12 @@ uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf) DU_LOG("\nERROR --> DU_APP : Invalid IE received in F1SetupRsp:%ld", f1SetRspMsg->protocolIEs.list.array[idx]->id); } - duProcF1SetupRsp(); } + duProcF1SetupRsp(); freeAperDecodeF1SetupRsp(f1SetRspMsg); - - duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen; - DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize); - if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP) - { - DU_LOG("\nERROR --> F1AP : Memory allocation failed to store the buf of F1setup response"); - return RFAILED; - } - memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen); + + addOrModifyE2NodeComponent(E2_NODE_COMPONENT_ADD, false, recvBufLen, recvBuf); if(BuildAndSendE2SetupReq() != ROK) { @@ -15636,35 +15961,35 @@ uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg) { if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0) { - dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size; - DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize); - if(dlMsg.rrcMsgPdu) - { - memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\ - dlMsg.rrcMsgSize); - } - else - { - DU_LOG("\nERROR --> DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()"); - return RFAILED; - } - } - else - { - DU_LOG("\nERROR --> DU_APP : RRC Container Size is invalid:%ld",\ - f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size); - return RFAILED; - } - break; - } - case ProtocolIE_ID_id_RRCDeliveryStatusRequest: - { - dlMsg.deliveryStatRpt = true; - break; - } - default: - DU_LOG("\nERROR --> DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld", - f1DlRrcMsg->protocolIEs.list.array[idx]->id); + dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size; + DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize); + if(dlMsg.rrcMsgPdu) + { + memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\ + dlMsg.rrcMsgSize); + } + else + { + DU_LOG("\nERROR --> DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()"); + return RFAILED; + } + } + else + { + DU_LOG("\nERROR --> DU_APP : RRC Container Size is invalid:%ld",\ + f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size); + return RFAILED; + } + break; + } + case ProtocolIE_ID_id_RRCDeliveryStatusRequest: + { + dlMsg.deliveryStatRpt = true; + break; + } + default: + DU_LOG("\nERROR --> DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld", + f1DlRrcMsg->protocolIEs.list.array[idx]->id); } } @@ -15963,6 +16288,13 @@ void FreeUeContextModResp(F1AP_PDU_t *f1apMsg) break; case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID: break; + case ProtocolIE_ID_id_DUtoCURRCInformation: + { + DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.\ + cellGroupConfig.buf, ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\ + DUtoCURRCInformation.cellGroupConfig.size); + break; + } case ProtocolIE_ID_id_DRBs_SetupMod_List: { FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\ @@ -16210,6 +16542,7 @@ uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb) ret = ROK; break; } + FreeUeContextModResp(f1apMsg); return ret; }