+ /* Initialize the F1Setup members */
+ DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
+ if(f1SetupReq->protocolIEs.list.array == NULLP)
+ {
+ break;
+ }
+ for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
+ {
+ DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
+ sizeof(F1SetupRequestIEs_t));
+ if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
+ {
+ break;
+ }
+ }
+
+ ieIdx = 0;
+ /*TransactionID*/
+ f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
+ F1SetupRequestIEs__value_PR_TransactionID;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
+ TRANS_ID;
+
+ /*DU ID*/
+ ieIdx++;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
+ F1SetupRequestIEs__value_PR_GNB_DU_ID;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
+ sizeof(uint8_t);
+
+ DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
+ if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
+ NULLP)
+ {
+ break;
+ }
+
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
+ duCfgParam.duId;
+
+ /*DU Name*/
+ if(duCfgParam.duName != NULL)
+ {
+ ieIdx++;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
+ strlen((char *)duCfgParam.duName);
+ DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
+ GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
+ if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
+ buf == NULLP)
+ {
+ break;
+ }
+ strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
+ choice.GNB_DU_Name.buf,
+ (char*)&duCfgParam.duName);
+
+ }
+
+ /*Served Cell list */
+ ieIdx++;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
+ ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
+ F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
+ duServedCell = &f1SetupReq->protocolIEs.list.\
+ array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
+ if(BuildServedCellList(duServedCell))
+ {
+ break;
+ }
+ /*RRC Version*/
+ ieIdx++;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
+ ProtocolIE_ID_id_GNB_DU_RRC_Version ;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
+ F1SetupRequestIEs__value_PR_RRC_Version;
+ rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
+ if(BuildRrcVer(rrcVer))
+ {
+ break;
+ }
+ xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
+
+ /* Encode the F1SetupRequest type as APER */
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
+ encBuf);
+
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for F1SetupRequest\n");
+ for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
+ {
+ printf("%x",encBuf[ieIdx]);
+ }
+ }
+
+ /* Sending msg */
+ if(sendF1APMsg() != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Sending F1 Setup request failed");
+ break;
+ }
+
+ ret=ROK;
+ break;
+ }while(true);
+
+ FreeF1SetupReq(f1apMsg);
+
+ return ret;
+}/* End of BuildAndSendF1SetupReq */
+
+/*******************************************************************
+ *
+ * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
+ *
+ * @details
+ *
+ * Function : freeCellsToModifyItem
+ *
+ * Functionality: Deallocating memory of variables allocated in
+ * BuildAndSendDUConfigUpdate function
+ *
+ * @params[in] Served_Cells_To_Modify_Item_t *modifyItem
+ *
+ * @return ROK - void
+ *
+ * ****************************************************************/
+
+void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
+{
+ uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
+ ServedPLMNs_Item_t *servedPlmnItem = NULLP;
+ SliceSupportItem_t *sliceSupportItem = NULLP;
+
+ DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
+ DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
+
+ DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
+ modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
+ DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
+ modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
+
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
+ {
+ servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
+
+ DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
+
+ if(servedPlmnItem->iE_Extensions != NULLP)
+ {
+ if(servedPlmnItem->iE_Extensions->list.array != NULLP)
+ {
+ if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
+ {
+ if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
+ list.array != NULLP)
+ {
+ for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
+ extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
+ {
+ if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx] != NULLP)
+ {
+
+ sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
+ SliceSupportList.list.array[sliceLstIdx];
+
+ DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
+ if(sliceSupportItem->sNSSAI.sD != NULLP)
+ {
+ DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
+ DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
+ }
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
+ SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
+ }
+ }
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
+ choice.SliceSupportList.list.array,\
+ servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
+ extensionValue.choice.SliceSupportList.list.size);
+ }
+ }
+ for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
+ {
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
+ }
+ DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
+ }
+ DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
+ }
+ }
+ for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
+ {
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
+ modifyItem->served_Cell_Information.servedPLMNs.list.size);
+ }
+
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
+ {
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
+ {
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
+ array[arrIdx], sizeof(FreqBandNrItem_t));
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
+ }
+
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
+ {
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
+ array[arrIdx], sizeof(FreqBandNrItem_t));
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
+ }
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
+ }
+
+ DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
+ modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
+}
+
+/*******************************************************************
+ *
+ * @brief Deallocating memory of BuildAndSendDUConfigUpdate
+ *
+ * @details
+ *
+ * Function : FreeDUConfigUpdate
+ *
+ * Functionality: Deallocating memory of variables allocated in
+ * BuildAndSendDUConfigUpdate function
+ *
+ * @params[in] F1AP_PDU_t *f1apDuCfg
+ *
+ * @return ROK - void
+ *
+ * ****************************************************************/
+void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
+{
+ uint8_t 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;
+
+ if(f1apDuCfg != NULLP)
+ {
+ if(f1apDuCfg->choice.initiatingMessage != NULLP)
+ {
+ duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
+ value.choice.GNBDUConfigurationUpdate;
+ if(duCfgUpdate->protocolIEs.list.array != NULLP)
+ {
+ for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
+ {
+ if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
+ {
+ switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
+ {
+ cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
+ value.choice.Served_Cells_To_Modify_List;
+ if(cellsToModify->list.array != NULLP)
+ {
+ for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
+ {
+ if(cellsToModify->list.array[cellModifyIdx] != NULLP)
+ {
+ freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
+ Served_Cells_To_Modify_Item);
+ DU_FREE(cellsToModify->list.array[cellModifyIdx],\
+ sizeof(Served_Cells_To_Modify_ItemIEs_t));
+ }
+ }
+ DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
+ }
+ break;
+ }
+ case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
+ {
+ cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
+ value.choice.Served_Cells_To_Delete_List;
+ if(cellsToDelete->list.array != NULLP)
+ {
+ for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
+ {
+ if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
+ {
+ deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
+ cellsToDelete->list.array[cellDeleteIdx]);
+ deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
+ DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
+ deleteItem->oldNRCGI.pLMN_Identity.size);
+ DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
+ deleteItem->oldNRCGI.nRCellIdentity.size);
+ DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
+ sizeof(Served_Cells_To_Delete_ItemIEs_t));
+ }
+ }
+ DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
+ }
+
+ break;
+ }
+ case ProtocolIE_ID_id_gNB_DU_ID:
+ {
+ DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
+ break;
+ }
+ }
+ DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
+ sizeof(GNBDUConfigurationUpdateIEs_t));
+ }
+ }
+ DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
+ }
+ DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
+ }
+ DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fills Served Plmns required in ServCellInfo IE
+ *
+ * @details
+ *
+ * Function : fillServedPlmns
+ *
+ * Functionality: Fills Served Plmns required in ServCellInfo IE
+ *
+ * @params[in] Pointer to ServedPLMNs_List_t *
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
+{
+ uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
+
+ servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
+ DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
+ array[arrayIdx]->pLMN_Identity.size);
+ if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
+ {
+ DU_LOG("ERROR --> DU_APP : fillServedPlmns(): Memory allocation failed");
+ return RFAILED;
+ }
+ buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
+ servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
+ DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
+ if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
+ {
+ DU_LOG("ERROR --> DU_APP : fillServedPlmns(): Memory allocation failed");
+ return RFAILED;
+ }
+
+ ieListCnt=1;
+ servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
+ servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
+ DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.size);
+ if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
+ {
+ DU_LOG("ERROR --> DU_APP : fillServedPlmns(): Memory allocation failed");
+ return RFAILED;
+ }
+ for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
+ {
+ DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
+ sizeof(ServedPLMNs_ItemExtIEs_t));
+ if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
+ {
+ DU_LOG("ERROR --> DU_APP : fillServedPlmns(): Memory allocation failed");
+ return RFAILED;
+ }
+ }
+
+ ieIdx = 0;
+ elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
+ servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
+ servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
+ servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
+ ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
+ servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.count = elementCnt;
+ servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.size = elementCnt * sizeof(SliceSupportItem_t *);
+ DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array,servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
+ if(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array == NULLP)
+ {
+ DU_LOG("ERROR --> DU_APP : fillServedPlmns(): Memory allocation failed");
+ return RFAILED;
+ }
+
+ for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
+ {
+ DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
+ if(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx] == NULLP)
+ {
+ DU_LOG("ERROR --> DU_APP : fillServedPlmns(): Memory allocation failed");
+ return RFAILED;
+ }
+
+ servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
+ DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
+ sNSSAI.sST.size);
+
+ if(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
+ {
+ DU_LOG("ERROR --> DU_APP : fillServedPlmns(): Memory allocation failed");
+ return RFAILED;
+ }
+ servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] = duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
+ cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
+
+ DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
+ if(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
+ {
+ DU_LOG("ERROR --> DU_APP : fillServedPlmns(): Memory allocation failed");
+ return RFAILED;
+ }
+ servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
+ DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sD->size);
+ if(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
+ {
+ DU_LOG("ERROR --> DU_APP : fillServedPlmns(): Memory allocation failed");
+ return RFAILED;
+ }
+ memcpy(servedPlmn->list.array[arrayIdx]->\
+ iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
+ cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
+ servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
+ list.array[sliceLstIdx]->sNSSAI.sD->size);
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills Nr Fdd Info required in ServCellInfo IE
+ *
+ * @details
+ *
+ * Function : fillNrFddInfo
+ *
+ * Functionality: Fills Nr Fdd Info required in ServCellInfo IE
+ *
+ * @params[in] Pointer to NR_Mode_Info_t *
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
+{
+ nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
+ f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
+ nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
+ nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
+ DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
+ array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
+ if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
+ {
+ return RFAILED;
+ }
+ DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
+ sizeof(FreqBandNrItem_t));
+ if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
+ {
+ return RFAILED;
+ }
+ nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
+ duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
+ freqBand[0].nrFreqBand;
+ nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
+ nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
+ dlNrFreqInfo.nrArfcn;
+ nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
+ nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
+ DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
+ choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
+ if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
+ {
+ return RFAILED;
+ }
+ DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
+ sizeof(FreqBandNrItem_t));
+ if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
+ {
+ return RFAILED;
+ }
+ nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
+ duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
+ freqBand[0].nrFreqBand;
+ nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
+
+ /*Transmission Bandwidth*/
+ nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
+ f1Mode.mode.fdd.ulTxBw.nrScs;
+ nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
+ f1Mode.mode.fdd.ulTxBw.nrb;
+ nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
+ f1Mode.mode.fdd.dlTxBw.nrScs;
+ nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
+ f1Mode.mode.fdd.dlTxBw.nrb;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills ServCellInfo IE
+ *
+ * @details
+ *
+ * Function : fillServedCellInfo
+ *
+ * Functionality: Fills ServCellInfo
+ *
+ * @params[in] Pointer to Served_Cell_Information_t *
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
+{
+ uint8_t tmp, ieIdx, ieListCnt;
+
+ /*nRCGI*/
+ srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
+ DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
+ srvCellInfo->nRCGI.pLMN_Identity.size);
+ if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
+ {
+ return RFAILED;
+ }
+ buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
+ srvCellInfo->nRCGI.pLMN_Identity.buf);
+ srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
+ DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
+ srvCellInfo->nRCGI.nRCellIdentity.size);
+ if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
+ {
+ return RFAILED;
+ }
+ for (tmp = 0 ; tmp < srvCellInfo->\
+ nRCGI.nRCellIdentity.size-1 ; tmp++)
+ {
+ srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
+ }
+ srvCellInfo->nRCGI.nRCellIdentity.buf[4] = duCfgParam.sib1Params.cellIdentity;
+ srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
+
+ /*nRPCI*/
+ srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
+
+ /*servedPLMNs*/
+ ieListCnt = 1;
+ srvCellInfo->servedPLMNs.list.count = ieListCnt;
+ srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
+ DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
+ srvCellInfo->servedPLMNs.list.size);
+ if(srvCellInfo->servedPLMNs.list.array == NULLP)
+ {
+ return RFAILED;
+ }
+ for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
+ {
+ DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
+ sizeof(ServedPLMNs_Item_t));
+ if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
+ {
+ return RFAILED;
+ }
+ }
+ if(fillServedPlmns(&srvCellInfo->servedPLMNs))
+ {
+ return RFAILED;
+ }
+
+ /*nR Mode Info with FDD*/
+ srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
+ DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
+ sizeof(FDD_Info_t));
+ if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
+ {
+ return RFAILED;
+ }
+ if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
+ return RFAILED;
+
+ /*Measurement timing Config*/
+ srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
+ DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
+ buf,srvCellInfo->measurementTimingConfiguration.size);
+ if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
+ {
+ return RFAILED;
+ }
+ srvCellInfo->measurementTimingConfiguration.\
+ buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills ServCellToModItem IE
+ *
+ * @details
+ *
+ * Function : fillServCellToModItem
+ *
+ * Functionality: Fills ServCellToModItem IE
+ *
+ * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
+{
+ uint8_t ieIdx;
+
+ /*pLMN_Identity*/
+ modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
+ DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
+ if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
+ {
+ return RFAILED;
+ }
+ buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
+ modifyItem->oldNRCGI.pLMN_Identity.buf);
+
+ /*nRCellIdentity*/
+ modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
+ DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
+ modifyItem->oldNRCGI.nRCellIdentity.size);
+ if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
+ {
+ return RFAILED;
+ }
+ for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
+ {
+ modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
+ }
+ modifyItem->oldNRCGI.nRCellIdentity.buf[4] = duCfgParam.sib1Params.cellIdentity;
+ modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
+
+ if(fillServedCellInfo(&modifyItem->served_Cell_Information))
+ return RFAILED;
+ else
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds ServCellToModList
+ *
+ * @details
+ *
+ * Function : buildServCellToModList
+ *
+ * Functionality: Builds the serv cell to Mod List
+ *
+ * @params[in] Pointer to Served_Cells_To_Modify_List_t *
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
+{
+ uint8_t ieListCnt, ieIdx;
+ Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
+
+ ieListCnt = 1;
+ cellsToModify->list.count = ieListCnt;
+ cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
+ DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
+ if(cellsToModify->list.array == NULLP)
+ {
+ return RFAILED;
+ }
+ for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
+ {
+ DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
+ if(cellsToModify->list.array[ieIdx] == NULLP)
+ {
+ return RFAILED;
+ }
+ }
+ cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
+ cellsToModify->list.array[0]->criticality = Criticality_reject;
+ cellsToModify->list.array[0]->value.present =\
+ Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
+ modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
+
+ if(fillServCellToModItem(modifyItem))
+ return RFAILED;
+ else
+ return ROK;
+}
+/*******************************************************************
+ *
+ * @brief filling the DeleteItemList
+ *
+ * @details
+ *
+ * Function : fillCellToDeleteItem
+ *
+ * Functionality: Filling the DeleteItemIe
+ *
+ * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
+{
+ uint8_t arrIdx;
+ Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
+
+ deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
+ deleteItemIe->criticality = Criticality_reject;
+ deleteItemIe->value.present =\
+ Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
+ deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
+
+ /*pLMN_Identity*/
+ deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
+ DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
+ if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
+ {
+ DU_LOG("ERROR --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
+ return RFAILED;
+ }
+ buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
+ deleteItem->oldNRCGI.pLMN_Identity.buf);
+
+ /*nRCellIdentity*/
+ deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
+ DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
+ deleteItem->oldNRCGI.nRCellIdentity.size);
+ if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
+ {
+ DU_LOG("ERROR --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
+ return RFAILED;
+ }
+ for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
+ {
+ deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
+ }
+ deleteItem->oldNRCGI.nRCellIdentity.buf[4] = duCfgParam.sib1Params.cellIdentity;
+ deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
+ return ROK;
+}
+/*******************************************************************
+ *
+ * @brief Builds ServCellToDeleteList
+ *
+ * @details
+ *
+ * Function : buildServCellToDeleteList
+ *
+ * Functionality: Builds the serv cell to delete List
+ *
+ * @params[in] Pointer to Served_Cells_To_Delete_List_t *
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
+{
+ uint8_t ieListCnt, arrIdx;
+
+ ieListCnt = 1;
+ cellsToDelete->list.count = ieListCnt;
+ cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
+
+ DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
+ if(cellsToDelete->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
+ return RFAILED;
+ }
+
+ for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
+ {
+ DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
+ if(cellsToDelete->list.array[arrIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
+ return RFAILED;
+ }
+ }
+
+ arrIdx=0;
+ if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
+ return RFAILED;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds and sends the DUConfigUpdate
+ *
+ * @details
+ *
+ * Function : BuildAndSendDUConfigUpdate
+ *
+ * Functionality: Constructs the DU Update message and sends
+ * it to the CU through SCTP.
+ *
+ * @params[in] void **buf,Buffer to which encoded pattern is written into
+ * @params[in] int *size,size of buffer
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
+{
+ uint8_t ret =0, ieIdx=0, elementCnt=0;
+ bool memAlloctionFailure = false;
+ F1AP_PDU_t *f1apDuCfg = NULLP;
+ GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+
+ memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
+ ret= RFAILED;
+
+ while(true)
+ {
+ DU_LOG("\nINFO --> F1AP : Building DU config update\n");
+ /* Allocate the memory for F1DuCfg */
+ DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
+ if(f1apDuCfg == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
+ break;
+ }
+
+ f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
+ DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
+ if(f1apDuCfg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
+ break;
+ }
+
+ f1apDuCfg->choice.initiatingMessage->procedureCode = \
+ ProcedureCode_id_gNBDUConfigurationUpdate;
+ f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
+ f1apDuCfg->choice.initiatingMessage->value.present = \
+ InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
+ duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
+ choice.GNBDUConfigurationUpdate;
+ elementCnt = 3;
+ duCfgUpdate->protocolIEs.list.count = elementCnt;
+ duCfgUpdate->protocolIEs.list.size = \
+ elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
+
+ /* Initialize the F1Setup members */
+ DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
+ if(duCfgUpdate->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("ERROR --> F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
+ break;
+ }
+ for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
+ {
+ DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
+ if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
+ {
+ DU_LOG("ERROR --> F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
+ memAlloctionFailure = true;
+ break;
+ }
+ }
+
+ if(memAlloctionFailure == true)
+ {
+ break;
+ }
+ /*TransactionID*/
+ ieIdx = 0;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
+ GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
+
+ ieIdx++;
+ if(servCellAction == SERV_CELL_TO_MODIFY)
+ {
+ /*Served Cell to Modify */
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
+ ProtocolIE_ID_id_Served_Cells_To_Modify_List;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
+ GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
+ if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
+ Served_Cells_To_Modify_List))
+ {
+ DU_LOG("ERROR --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
+ break;
+ }
+ }
+ else
+ {
+ /*Served Cell to Delete */
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
+ ProtocolIE_ID_id_Served_Cells_To_Delete_List;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
+ GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
+ if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
+ Served_Cells_To_Delete_List)!=ROK)
+ {
+ DU_LOG("ERROR --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
+ break;
+ }
+
+ }
+ // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
+ /*GNB DU ID */
+ ieIdx++;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
+ GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
+ DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
+ if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
+ {
+ DU_LOG("ERROR --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
+ break;
+ }
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
+
+ xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
+
+ /* Encode the DU Config Update type as APER */
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
+
+ /* Checking encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("ERROR --> F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for DUConfigUpdate\n");
+ for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
+ {
+ printf("%x",encBuf[ieIdx]);
+ }
+ }
+ /* Sending msg */
+ if(sendF1APMsg() != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Sending GNB-DU Config Update failed");
+ break;
+ }
+
+ ret = ROK;
+ break;
+ }
+
+ addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
+ return ret;
+}
+
+
+/*******************************************************************
+ *
+ * @brief free the ULRRCMessageTransfer
+ *
+ * @details
+ *
+ * Function : FreeULRRCMessageTransfer
+ *
+ * Functionality: Deallocating the memory of variable allocated in
+ * FreeULRRCMessageTransfer
+ *
+ * @params[in]
+ *
+ * @return ROK - void
+ *
+ ******************************************************************/
+void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
+{
+ uint8_t idx1;
+ ULRRCMessageTransfer_t *ulRRCMsg;
+
+ if(f1apMsg != NULLP)
+ {
+ if(f1apMsg->choice.initiatingMessage != NULLP)
+ {
+ ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
+ if(ulRRCMsg->protocolIEs.list.array != NULLP)
+ {
+ for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
+ {
+ if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
+ {
+ if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
+ ULRRCMessageTransferIEs__value_PR_RRCContainer)
+ {
+ DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
+ }
+ DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
+ }
+ }
+ DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
+ }
+ DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
+ }
+ DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
+ }
+}
+/*******************************************************************
+ *
+ * @brief Builds and sends the ULRRCMessageTransfer
+ *
+ * @details
+ *
+ * Function : BuildAndSendULRRCMessageTransfer
+ *
+ * Functionality: Constructs the UL RRC Message Transfer and sends
+ * it to the CU through SCTP.
+ *
+ * @params[in]
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb ueCb, uint8_t lcId, \
+ uint16_t msgLen, uint8_t *rrcMsg)
+{
+ uint8_t elementCnt =0;
+ uint8_t idx1 =0;
+ uint8_t idx =0;
+ F1AP_PDU_t *f1apMsg = NULLP;
+ ULRRCMessageTransfer_t *ulRRCMsg = NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+ uint8_t ret =RFAILED;
+
+ memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
+
+ while(true)
+ {
+ DU_LOG("\n INFO --> F1AP : Building UL RRC Message Transfer Message\n");
+
+ DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
+ if(f1apMsg == NULLP)
+ {
+ DU_LOG(" ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ break;
+ }
+ f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
+ DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
+ if(f1apMsg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG(" ERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ break;
+ }
+ f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
+ f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
+ f1apMsg->choice.initiatingMessage->value.present = \
+ InitiatingMessage__value_PR_ULRRCMessageTransfer;
+ ulRRCMsg =
+ &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
+ elementCnt = 4;
+ ulRRCMsg->protocolIEs.list.count = elementCnt;
+ ulRRCMsg->protocolIEs.list.size = \
+ elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
+
+ /* Initialize the F1Setup members */
+ DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
+ if(ulRRCMsg->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG(" ERROR --> F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
+ break;
+ }
+ for(idx=0; idx<elementCnt; idx++)
+ {
+ DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
+ if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
+ {
+ break;
+ }
+ }
+
+ idx1 = 0;
+
+ /*GNB CU UE F1AP ID*/
+ ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
+ ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
+
+ /*GNB DU UE F1AP ID*/
+ idx1++;
+ ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
+ ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
+
+ /*SRBID*/
+ idx1++;
+ ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
+ ULRRCMessageTransferIEs__value_PR_SRBID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
+
+ /*RRCContainer*/
+ idx1++;
+ ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCContainer;
+ ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
+ ULRRCMessageTransferIEs__value_PR_RRCContainer;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
+ DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
+ if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
+ {
+ DU_LOG(" ERROR --> F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
+ break;
+ }
+ memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
+ memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
+ rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
+
+ xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
+
+ /* Encode the F1SetupRequest type as APER */
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
+ encBuf);
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ printf("%x",encBuf[i]);
+ }
+ }
+
+ /* Sending msg */
+ if(sendF1APMsg() != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Sending UL RRC Message Transfer Failed");
+ break;
+ }
+ ret = ROK;
+ break;
+ }
+ FreeULRRCMessageTransfer(f1apMsg);
+
+ return ret;
+}/* End of BuildAndSendULRRCMessageTransfer*/
+
+/*******************************************************************
+ *
+ * @brief Builds tag config
+ *
+ * @details
+ *
+ * Function : BuildTagConfig
+ *
+ * Functionality: Builds tag config in MacCellGroupConfig
+ *
+ * @params[in] TAG_Config *tag_Config
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
+{
+ struct TAG_Config__tag_ToAddModList *tagList;
+ uint8_t idx, elementCnt;
+
+ tagConfig->tag_ToReleaseList = NULLP;
+ tagConfig->tag_ToAddModList = NULLP;
+ DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
+ if(!tagConfig->tag_ToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ return RFAILED;
+ }
+
+ elementCnt = 1; //ODU_VALUE_ONE;
+ tagList = tagConfig->tag_ToAddModList;
+ tagList->list.count = elementCnt;
+ tagList->list.size = elementCnt * sizeof(struct TAG *);
+
+ tagList->list.array = NULLP;
+ DU_ALLOC(tagList->list.array, tagList->list.size);
+ if(!tagList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ return RFAILED;
+ }
+
+ for(idx=0; idx<tagList->list.count; idx++)
+ {
+ tagList->list.array[idx] = NULLP;
+ DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
+ if(!tagList->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ tagList->list.array[idx]->tag_Id = TAG_ID;
+ tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds PHR Config
+ *
+ * @details
+ *
+ * Function : BuildPhrConfig
+ *
+ * Functionality: Builds phrConfig in MacCellGroupConfig
+ *
+ * @params[in] PHR Config *
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
+{
+
+ phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
+ phrConfig->choice.setup = NULLP;
+ DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
+ if(!phrConfig->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildPhrConfig");
+ return RFAILED;
+ }
+
+ phrConfig->choice.setup->phr_PeriodicTimer = PHR_PERIODIC_TMR;
+ phrConfig->choice.setup->phr_ProhibitTimer = PHR_PROHIBHIT_TMR;
+ phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
+ phrConfig->choice.setup->multiplePHR = false;
+ phrConfig->choice.setup->dummy = false;
+ phrConfig->choice.setup->phr_Type2OtherCell = false;
+ phrConfig->choice.setup->phr_ModeOtherCG = PHR_MODE_OTHER_CG;
+
+ return ROK;
+}