/* This file contains F1AP message handler functions */
#include "common_def.h"
#include "OCTET_STRING.h"
-#include "cu_stub_sctp.h"
-#include "cu_stub_egtp.h"
-#include "cu_f1ap_msg_hdl.h"
-#include "cu_stub.h"
-
#include "BIT_STRING.h"
#include "odu_common_codec.h"
#include "ProtocolIE-Field.h"
#include "UE-CapabilityRAT-Container.h"
#include "UE-CapabilityRAT-ContainerList.h"
#include "UE-CapabilityRAT-ContainerListRRC.h"
+#include "HandoverPreparationInformationRrc-IEs.h"
+#include "HandoverPreparationInformationRrc.h"
#include "SupportedBandwidth.h"
#include "FeatureSetUplinkPerCC.h"
#include "FeatureSetDownlinkPerCC.h"
#include "DRB-ToAddModList.h"
#include "DRB-ToAddMod.h"
#include "SDAP-Config.h"
+#include "SSB-MTC.h"
+#include "MeasTiming.h"
+#include "MeasTimingList.h"
+#include "MeasurementTimingConfigurationRrc-IEs.h"
+#include "MeasurementTimingConfigurationRrc.h"
+#include "PDCP-Config.h"
+#include "RSRP-Range.h"
+#include "RSRQ-Range.h"
+#include "SINR-Range.h"
+#include "ThresholdNR.h"
+#include "MeasObjectToAddMod.h"
+#include "MeasObjectNR.h"
+#include "MeasObjectToAddModList.h"
+#include "EventTriggerConfig.h"
+#include "ReportConfigNR.h"
+#include "ReportConfigToAddMod.h"
+#include "ReportConfigToAddModList.h"
+#include "MeasIdToAddMod.h"
+#include "MeasIdToAddModList.h"
+#include "FilterCoefficient.h"
+#include "QuantityConfigNR.h"
+#include "QuantityConfig.h"
+#include "MeasConfigRrc.h"
+#include "AS-Config.h"
+#include "RRCReconfiguration-v1530-IEs.h"
+#include "CNUEPagingIdentity.h"
+#include "PagingCell-Item.h"
+#include "UL-DCCH-Message.h"
+
+#include "cu_stub_sctp.h"
+#include "cu_stub_egtp.h"
+#include "cu_f1ap_msg_hdl.h"
+#include "cu_stub.h"
-/* MACRO for CUtoDURRCInformation */
-#define CELL_GRP_ID 1
-#define FREQ_DOM_RSRC_SIZE 6
-#define CORESET0_END_PRB 48
-#define CORESET1_NUM_PRB 24
-#define PDCCH_CTRL_RSRC_SET_ONE_ID 1
-#define PDCCH_CTRL_RSRC_SET_ONE_DURATION 2 /* Duration for control resource set id i */
-#define PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY 1 /* Precoded granularity */
-#define PDCCH_SRCH_SPC_TWO_ID 2
-#define NR_PCI 1
-#define SCRAMBLING_ID NR_PCI
-#define DMRS_ADDITIONAL_POS 0 /* DMRS Additional poistion */
-#define PDCCH_SYMBOL_WITHIN_SLOT 128 /* Symbol within Slot Value */
-#define PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE 7 /* Num of candidate at aggregation level 1 */
-#define PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE 7 /* Num of candidate at aggregation level 2 */
-#define PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE 4 /* Num of candidate at aggregation level 4 */
-#define PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE 2 /* Num of candidate at aggregation level 8 */
-#define PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE 1 /* Num of candidate at aggregation level 16 */
-#define PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT 0 /* format 0-0 and 1-0 */
-#define PDCCH_SERACH_SPACE_DCI_FORMAT 0
-
-/* MACRO Ddefine for PDSCH Configuration */
-#define PDSCH_K0 0
-#define PDSCH_RES_ALLOC_TYPE 1 /* Resource allocation type */
-#define PDSCH_MAX_CODEWORD_SCH_BY_DCI 0 /* Max num of codewords scheduled by DCI */
-#define PDSCH_RBG_SIZE 0 /* 0: config1 */
-#define PDSCH_NUM_HARQ_PROC 5
-#define PDSCH_MAPPING_TYPE_A 0
-#define PDSCH_MAPPING_TYPE_B 1
-
-/* MACRO Define for PUSCH Configuration */
-#define PUSCH_K2_CFG1 1
-#define PUSCH_K2_CFG2 2
-
-#define PUSCH_MSG3_DELTA_PREAMBLE 0
-#define PUSCH_P0_NOMINAL_WITH_GRANT -70
-#define PUSCH_TRANSFORM_PRECODER 1 /* 1: Disabled */
-#define PUSCH_MAX_MIMO_LAYERS 1
-#define PUSCH_PROCESS_TYPE2_ENABLED false
-#define PUSCH_MAPPING_TYPE_A 0
-#define PUSCH_MAPPING_TYPE_B 1
-
-/* MACRO defines for SRC config */
-#define SRS_RSRC_ID 1
-#define SRS_RSET_ID 1
-#define SRS_COMB_OFFSET_N2 0
-#define SRS_CYCLIC_SHIFT_N2 0
-#define SRS_FREQ_DOM_POS 0
-#define SRS_FREQ_DOM_SHIFT 0
-#define C_SRS 0
-#define B_SRS 0
-#define B_HOP 0
-#define SRS_SEQ_ID 0
-#define APERIODIC_SRS_RESRC_TRIGGER 1
-
-/* Macro definitions for DUtoCuRrcContainer */
-#define CELL_GRP_ID 1
-#define SCH_REQ_ID 0
-#define SR_PROHIBIT_TMR 5
-#define SR_TRANS_MAX 2
-#define PERIODIC_BSR_TMR 2
-#define RETX_BSR_TMR 5
-#define SR_DELAY_TMR 6
-#define TAG_ID 0
-#define TIME_ALIGNMENT_TMR 7
-#define PHR_PERIODIC_TMR 7
-#define PHR_PROHIBHIT_TMR 0
-#define PHR_PWR_FACTOR_CHANGE 3
-#define PHR_MODE_OTHER_CG 0
-#define RLC_LCID 1
-#define SRB_ID_1 1
-#define SN_FIELD_LEN 0
-#define T_POLL_RETRANSMIT 8
-#define POLL_PDU 0
-#define POLL_BYTE 43
-#define MAX_RETX_THRESHOLD 5
-#define T_REASSEMBLY 8
-#define T_STATUS_PROHIBHIT 7
-#define MAC_LC_PRIORITY 1
-#define PRIORTISIED_BIT_RATE 15
-#define BUCKET_SIZE_DURATION 5
-#define LC_GRP 0
-#define P_NR_FR1 0
-#define PDSCH_HARQ_ACK_CODEBOOK 1
-#define SERV_CELL_IDX 0
-#define RLM_SYNC_OUT_SYNC_THRESHOLD 0
-#define ACTIVE_DL_BWP_ID 0
-#define ACTIVE_UL_BWP_ID 0
-#define SCRAMBLING_ID NR_PCI
-#define DMRS_ADDITIONAL_POS 0 /* DMRS Additional poistion */
-#define RES_ALLOC_TYPE 1 /* Resource allocation type */
-#define FIVE_QI_VALUE9 9 /*spec 23.501, Table 5.7.4-1*/
-#define FIVE_QI_VALUE8 8 /*spec 23.501, Table 5.7.4-1*/
-#define PDU_SESSION_ID_1 1
-#define PDU_SESSION_ID_2 2
-#define INVALID_PDU_SESSION_ID -1
+uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
+uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
/*******************************************************************
*
* RFAILED - failure
*
* ****************************************************************/
-S16 SendF1APMsg(Region region, Pool pool)
+S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
{
Buffer *mBuf = NULLP;
{
ODU_PRINT_MSG(mBuf, 0,0);
- if(sctpSend(mBuf) != ROK)
+ if(sctpSend(duId, mBuf) != ROK)
{
DU_LOG("\nERROR --> F1AP : SCTP Send failed");
ODU_PUT_MSG_BUF(mBuf);
return ROK;
} /* SendF1APMsg */
-/*******************************************************************
- *
- * @brief Builds NRCell ID
- *
- * @details
- *
- * Function : BuildNrCellId
- *
- * Functionality: Building the NR Cell ID
- *
- * @params[in] BIT_STRING_t *nrcell
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-
-S16 BuildNrCellId(BIT_STRING_t *nrcell)
-{
- memset(nrcell->buf, 0, nrcell->size);
- nrcell->buf[4] = 16;
- nrcell->bits_unused = 4;
- nrcell->size = 5 * sizeof(uint8_t);
- return ROK;
-}
-
/********************************************************************
*
* @brief Builds and sends the F1SetupResponse
* RFAILED - failure
*
* ****************************************************************/
-S16 BuildAndSendF1SetupRsp(BIT_STRING_t *nrcellId)
+uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
{
uint8_t idx,ieIdx;
uint8_t elementCnt,cellCnt;
f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
F1SetupResponseIEs__value_PR_GNB_CU_Name;
cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
- cuName->size = sizeof(cuCfgParams.cuName);
+ cuName->size = sizeof(cuCb.cuCfgParams.cuName);
CU_ALLOC(cuName->buf, sizeof(cuName->size));
if(cuName->buf == NULLP)
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
- strcpy((char*)cuName->buf, (char*)cuCfgParams.cuName);
+ strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
/*Cells to be activated list*/
idx++;
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
- buildPlmnId(cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
+ buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
- nRCGI.nRCellIdentity.size = 5;
+ nRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
- 5*sizeof(uint8_t));
+ cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
+ nRCGI.nRCellIdentity.size);
if(cellToActivate->list.array[0]->value.choice.\
Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
{
}
/* Need to check RRC Version */
- rrcVer->latest_RRC_Version.buf[0] = cuCfgParams.rrcVersion.rrcVer;
+ rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
if(rrcVer->iE_Extensions == NULLP)
}
/* Sending msg */
- if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
+ if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
{
DU_LOG("\nERROR --> F1AP : Sending F1 Setup Response failed");
return RFAILED;
*
* ****************************************************************/
-S16 BuildAndSendDUUpdateAck()
+uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
{
uint8_t idx;
uint8_t elementCnt;
}
/* Sending msg */
- if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
+ /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
+ if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
{
DU_LOG("\nERROR --> F1AP : Sending GNB-DU Config Update Ack failed");
return RFAILED;
return ROK;
}/* End of BuildAndSendDUUpdateAck*/
+
/*******************************************************************
*
* @brief deallocating the memory of F1reset msg
CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
+ break;
}
f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
+ break;
}
f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
if(f1ResetMsg->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
+ break;
}
for(idx=0; idx<elementCnt; idx++)
{
- CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
- if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
- break;
- }
+ CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
+ if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
+ break;
+ }
}
/*TransactionID*/
memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
- encBuf);
+ encBuf);
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode F1Reset structure (at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- break;
+ DU_LOG("\nERROR --> F1AP : Could not encode F1Reset structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for F1Reset\n");
- for(idx=0; idx< encBufSize; idx++)
- {
- DU_LOG("%x",encBuf[idx]);
- }
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for F1Reset\n");
+ for(idx=0; idx< encBufSize; idx++)
+ {
+ DU_LOG("%x",encBuf[idx]);
+ }
}
- if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
+ /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
+ if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending F1 Reset request failed");
- break;
+ DU_LOG("\nERROR --> F1AP : Sending F1 Reset request failed");
+ break;
}
ret = ROK;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t fillSrbCfg(uint8_t srbId, SRB_ToAddModList_t *bearerCfg)
+uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
{
- uint8_t elementCnt;
- uint8_t idx, ieId;
+ uint8_t elementCnt = 0;
+ uint8_t idx, ieId, srbIdx = 0;
+
+ for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
+ {
+ if(ueCb->srbList[srbIdx].cfgSentToUe == false)
+ elementCnt++;
+ }
+
if(bearerCfg != NULLP)
{
- elementCnt = 1;
bearerCfg->list.count = elementCnt;
- bearerCfg->list.size =\
- elementCnt * sizeof(SRB_ToAddMod_t *);
+ bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
if(bearerCfg->list.array != NULLP)
{
- for(idx = 0; idx < elementCnt; idx++)
- {
- CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
- if(bearerCfg->list.array[idx] == NULLP)
- {
- for(ieId = 0; ieId < idx; ieId++)
- {
- CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
- }
- CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
- return RFAILED;
- }
- }
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
+ if(bearerCfg->list.array[idx] == NULLP)
+ {
+ for(ieId = 0; ieId < idx; ieId++)
+ {
+ CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
+ }
+ CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
+ return RFAILED;
+ }
+ }
}
else
{
- return RFAILED;
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
+ return RFAILED;
}
+
idx = 0;
- bearerCfg->list.array[idx]->srb_Identity = srbId;
+ for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
+ {
+ if(ueCb->srbList[srbIdx].cfgSentToUe == false)
+ bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
+ }
}
return ROK;
}
*
* ****************************************************************/
-uint8_t fillMasterCellGroup(uint8_t ueId, OCTET_STRING_t *masterCellGroup)
+uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
{
uint8_t ret = ROK;
masterCellGroup->buf = NULLP;
- if(ueCb[ueId-1].f1apMsgDb.duToCuContainer.buf)
+ if(ueCb->f1apMsgDb.duToCuContainer.buf)
{
- masterCellGroup->size = ueCb[ueId-1].f1apMsgDb.duToCuContainer.size;
+ masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
if(masterCellGroup->buf != NULLP)
{
- memcpy(masterCellGroup->buf, ueCb[ueId-1].f1apMsgDb.duToCuContainer.buf,\
- masterCellGroup->size);
+ memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
}
else
{
- ret = RFAILED;
+ DU_LOG( "\nERROR --> F1AP : Master Cell Group buffer is NULL");
+ ret = RFAILED;
}
}
else
*
* ****************************************************************/
-uint8_t fillRRCSetupIE(uint8_t ueId, RRCSetup_IEs_t *rrcSetupIE)
+uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
{
- uint8_t ret = ROK;
+ uint8_t ret = ROK, srbIdx = 0;
if(rrcSetupIE)
{
CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
{
- ret = fillSrbCfg(SRB1, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
+ ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
}
if(ret == ROK)
{
- ret = fillMasterCellGroup(ueId, &rrcSetupIE->masterCellGroup);
+ ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
}
else
{
- CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
- ret = RFAILED;
+ CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
+ ret = RFAILED;
+ }
+
+ /* If SRB configuration are filled successfully in RRC Setup, mark these
+ * configurartion as sent to UE */
+ for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
+ {
+ if(ueCb->srbList[srbIdx].cfgSentToUe == false)
+ ueCb->srbList[srbIdx].cfgSentToUe = true;
}
}
return ret;
*
* ****************************************************************/
-uint8_t fillDlCcchRrcMsg(uint8_t ueId, RRCContainer_t *rrcContainer)
+uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
{
uint8_t ret = ROK;
uint16_t idx2;
DL_CCCH_Message_t dl_CCCH_Msg;
- asn_enc_rval_t encRetVal;
+ asn_enc_rval_t encRetVal;
if(rrcContainer != NULLP)
{
if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
{
dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
- dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.\
- present = RRCSetup__criticalExtensions_PR_rrcSetup;
+ dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
+ RRCSetup__criticalExtensions_PR_rrcSetup;
+
/* Fill RRC Setup IE */
- CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
- criticalExtensions.choice.rrcSetup, sizeof(RRCSetup_IEs_t));
- if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
- criticalExtensions.choice.rrcSetup != NULLP)
+ CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
+ sizeof(RRCSetup_IEs_t));
+ if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
{
- ret = fillRRCSetupIE(ueId, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
- criticalExtensions.choice.rrcSetup);
+ ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
if(ret == ROK)
{
}
}
+/*******************************************************************
+ *
+ * @brief Fills QOS flow configuration
+ *
+ * @details
+ *
+ * Function : fillQosFlowsToAdd
+ *
+ * Functionality: Fills QOS flow configuration
+ *
+ * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
{
uint8_t idx, ied, elementCnt;
*
* ****************************************************************/
-uint8_t fillDlDcchRrcMsg(RRCContainer_t *rrcContainer)
+uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
{
uint8_t ret = ROK;
- uint16_t idx2;
+ uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
DL_DCCH_Message_t dl_DCCH_Msg;
memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
asn_enc_rval_t encRetVal;
CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
if(dl_DCCH_Msg.message.choice.c1 != NULLP)
{
- dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
- CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
- if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
- {
- dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->rrc_TransactionIdentifier = 0;
- dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->criticalExtensions.\
- present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
- /* Fill RRC Reconfig IE */
- CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
- criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
- if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
- criticalExtensions.choice.rrcReconfiguration != NULLP)
- {
- ret = fillRrcReconfigIE(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
- criticalExtensions.choice.rrcReconfiguration);
+ dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
+ CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
+ if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
+ {
+ DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
+ fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, false);
+ if(ret == ROK)
+ {
+ /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
+ * configurartion as sent to UE */
+ for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
+ {
+ if(ueCb->srbList[srbIdx].cfgSentToUe == false)
+ ueCb->srbList[srbIdx].cfgSentToUe = true;
+ }
+ for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
+ {
+ if(ueCb->drbList[drbIdx].cfgSentToUe == false)
+ ueCb->drbList[drbIdx].cfgSentToUe = true;
+ }
- if(ret == ROK)
- {
- /* encode DL-DCCH message into RRC Container */
- xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
- memset(encBuf, 0, ENC_BUF_MAX_LEN);
- encBufSize = 0;
- encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
- /* Encode results */
- if(encRetVal.encoded == ENCODE_FAIL)
- {
- DU_LOG( "\nERROR --> F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- return RFAILED;
- }
- else
- {
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
- for(int i = 0; i< encBufSize; i++)
- {
- DU_LOG("%x",encBuf[i]);
- }
- rrcContainer->size = encBufSize;
- CU_ALLOC(rrcContainer->buf, rrcContainer->size);
- if(rrcContainer->buf != NULLP)
- {
- memset(rrcContainer->buf, 0, encBufSize);
- for(idx2 = 0; idx2 < encBufSize; idx2++)
- {
- rrcContainer->buf[idx2] = encBuf[idx2];
- }
- }
- }
- }
- else
- {
- DU_LOG("\nERROR --> F1AP: Failed to fill RrcReconfig IE at fillDlDcchRrcMsg()");
- }
- }
- else
- {
- DU_LOG("\nERROR --> F1AP: Memory Alloc failed for RRC Reconfig at fillDlDcchRrcMsg()");
- ret = RFAILED;
- }
- }
- else
- {
- DU_LOG("\nERROR --> F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
- ret = RFAILED;
- }
+ /* encode DL-DCCH message into RRC Container */
+ xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ return RFAILED;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
+ for(int i = 0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ rrcContainer->size = encBufSize;
+ CU_ALLOC(rrcContainer->buf, rrcContainer->size);
+ if(rrcContainer->buf != NULLP)
+ {
+ memset(rrcContainer->buf, 0, encBufSize);
+ for(idx2 = 0; idx2 < encBufSize; idx2++)
+ {
+ rrcContainer->buf[idx2] = encBuf[idx2];
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
+ ret = RFAILED;
+ }
}
else
{
- DU_LOG("\nERROR --> F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
- ret = RFAILED;
+ DU_LOG("\nERROR --> F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
+ ret = RFAILED;
}
}
else
*
* ****************************************************************/
-uint8_t BuildDLRRCContainer(uint8_t ueId, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
+uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
{
uint8_t ret, bufLen;
ret =ROK;
if(rrcMsgType == RRC_SETUP)
{
- ret = fillDlCcchRrcMsg(ueId, rrcContainer);
+ ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
if(ret == RFAILED)
- DU_LOG("\nERROR --> F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
+ DU_LOG("\nERROR --> F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
}
- else if(rrcMsgType == REGISTRATION_ACCEPT)
+ else if(rrcMsgType == RRC_SETUP_COMPLETE)
{
- /*Hardcoded RRC Container from reference logs*/
- char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
- bufLen =14;
+ DU_LOG("\nINFO --> F1AP : Sending Security mode command");
+ char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
+ bufLen =9;
rrcContainer->size = bufLen;
CU_ALLOC(rrcContainer->buf, rrcContainer->size);
if(rrcContainer->buf != NULLP)
{
- memset(rrcContainer->buf, 0, bufLen);
- memcpy(rrcContainer->buf, buf, bufLen);
+ memset(rrcContainer->buf, 0, bufLen);
+ memcpy(rrcContainer->buf, secModeBuf, bufLen);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure for RRC Container buffer");
+ ret = RFAILED;
}
}
- else if(rrcMsgType == RRC_RECONFIG)
+ else if(rrcMsgType == SECURITY_MODE_COMPLETE)
{
/*Hardcoded RRC Container from reference logs*/
- char buf[196]= {
- 0x00, 0x04, 0x00, 0xaa, 0x80, 0x40, 0x9a, 0x05, 0x20, 0x00, 0x05, 0xeb, 0xc0, 0x51, 0x50, 0x00,
- 0x03, 0x00, 0x03, 0xf7, 0x56, 0xec, 0x7f, 0x08, 0x42, 0x10, 0x80, 0x00, 0x10, 0x21, 0x47, 0x84,
- 0xd1, 0x00, 0x00, 0x00, 0x02, 0x81, 0x5d, 0x10, 0x0a, 0xc2, 0x44, 0x40, 0x2b, 0xb2, 0x07, 0x41,
- 0x87, 0xa8, 0x02, 0xc7, 0x00, 0x88, 0x05, 0x76, 0x40, 0xe8, 0x30, 0xf5, 0x40, 0x4c, 0x00, 0x10,
- 0x02, 0x00, 0xa5, 0x83, 0xe0, 0x60, 0x02, 0x10, 0x72, 0x01, 0x0c, 0xa0, 0xa0, 0xd8, 0x00, 0x00,
- 0x00, 0x01, 0x0f, 0x02, 0x3c, 0x01, 0x80, 0x10, 0x82, 0xb0, 0x40, 0x00, 0x00, 0x02, 0x1e, 0x04,
- 0x78, 0x07, 0x00, 0x21, 0x05, 0x61, 0x00, 0x00, 0x00, 0x04, 0x3c, 0x08, 0xf0, 0x16, 0x00, 0x42,
- 0x0a, 0xc3, 0x00, 0x00, 0x00, 0x08, 0x78, 0x11, 0xe0, 0x3c, 0x00, 0x84, 0x14, 0x00, 0x07, 0xe5,
- 0xc0, 0xa0, 0xd8, 0x42, 0x20, 0x02, 0x80, 0xa0, 0x02, 0x24, 0x47, 0xa0, 0x20, 0x27, 0xa1, 0x22,
- 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x24, 0x41, 0x20, 0xc0, 0x80, 0x00, 0x20, 0x80,
- 0x00, 0x25, 0x20, 0xa0, 0x38, 0x00, 0x00, 0x00, 0x44, 0xa2, 0x82, 0x69, 0xee, 0x0c, 0xad, 0xca,
- 0x4c, 0x2c, 0x8d, 0x2e, 0x6f, 0x2e, 0x69, 0x2d, 0xce, 0x8c, 0xae, 0x4d, 0xcc, 0xae, 0x80, 0x00,
- 0x00, 0x00, 0x00, 0x00};
- bufLen =196;
+ DU_LOG("\nINFO --> F1AP : Sending Registration accept");
+ char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
+ bufLen =14;
rrcContainer->size = bufLen;
CU_ALLOC(rrcContainer->buf, rrcContainer->size);
if(rrcContainer->buf != NULLP)
{
- memset(rrcContainer->buf, 0, bufLen);
- memcpy(rrcContainer->buf, buf, bufLen);
+ memset(rrcContainer->buf, 0, bufLen);
+ memcpy(rrcContainer->buf, buf, bufLen);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure for RRC Container buffer");
+ ret = RFAILED;
}
}
+ else if(rrcMsgType == UE_CONTEXT_SETUP_RSP)
+ {
+ DU_LOG("\nINFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
+ ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
+ if(ret == RFAILED)
+ DU_LOG("\nERROR --> F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
+ }
return ret;
}
+/*******************************************************************
+ *
+ * @brief Frees the DLRRCMessageTransfer
+ *
+ * @details
+ *
+ * Function : freeDlRrcMessageTransfer
+ *
+ * Functionality: Frees the DLRRCMessageTransfer
+ *
+ * @params[in]
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
+{
+ uint8_t idx=0;
+ DLRRCMessageTransfer_t *dlRRCMsg = NULLP;
+
+ if(f1apMsg)
+ {
+ dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
+ if(dlRRCMsg->protocolIEs.list.array)
+ {
+ idx = 3;
+ CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
+ dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
+ for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
+ {
+ CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
+ }
+ CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
+ }
+ CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
+ }
+}
+
/*******************************************************************
*
* @brief Builds and sends the DLRRCMessageTransfer
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t ueId, uint8_t srbId, uint8_t rrcMsgType)
+uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
{
uint8_t elementCnt = 0;
uint8_t ieId;
}
f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
- CU_ALLOC(f1apMsg->choice.initiatingMessage,
- sizeof(InitiatingMessage_t));
+ CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
{
- for(ieId=0; ieId<idx; ieId++)
- {
- CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId],\
- sizeof(DLRRCMessageTransferIEs_t));
- }
- CU_FREE(dlRRCMsg->protocolIEs.list.array,\
- dlRRCMsg->protocolIEs.list.size);
- CU_FREE(f1apMsg->choice.initiatingMessage,\
- sizeof(InitiatingMessage_t));
- CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
- return RFAILED;
+ for(ieId=0; ieId<idx; ieId++)
+ {
+ CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
+ }
+ CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
+ CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
+ CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
+ return RFAILED;
}
}
/* GNB CU UE F1AP ID */
idx = 0;
dlRRCMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
- dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
- DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
- dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueId;
+ dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
+ dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
/* GNB DU UE F1AP ID */
idx++;
- dlRRCMsg->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
- dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
- DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
- dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueId;
+ dlRRCMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
+ dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
+ dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
/* SRBID */
idx++;
dlRRCMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBID;
- dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
- DLRRCMessageTransferIEs__value_PR_SRBID;
+ dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
/* RRCContainer */
idx++;
dlRRCMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
- dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
- DLRRCMessageTransferIEs__value_PR_RRCContainer;
- BuildDLRRCContainer(ueId, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
+ dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
+ BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
- encBuf);
+ encBuf);
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
DU_LOG( "\nERROR --> F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
return RFAILED;
}
else
DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ DU_LOG("%x",encBuf[i]);
}
}
/* Sending msg */
- if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL) != ROK)
+ if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId) != ROK)
{
DU_LOG("\nERROR --> F1AP : Sending DL RRC Message Transfer Failed");
return RFAILED;
}
-
+ freeDlRrcMessageTransfer(f1apMsg);
return ROK;
}/* End of BuildAndSendDLRRCMessageTransfer */
*
* ****************************************************************/
-uint8_t setDlRRCMsgType(uint8_t ueId)
+uint8_t setDlRRCMsgType(CuUeCb *ueCb)
{
uint8_t rrcMsgType = 0;
- switch(ueCb[ueId -1].f1apMsgDb.dlRrcMsgCount)
+ switch(ueCb->f1apMsgDb.dlRrcMsgCount)
{
case RRC_SETUP:
- rrcMsgType = RRC_SETUP;
- break;
- case REGISTRATION_ACCEPT:
- rrcMsgType = REGISTRATION_ACCEPT;
- break;
- case UE_CONTEXT_SETUP_REQ:
- rrcMsgType = UE_CONTEXT_SETUP_REQ;
- break;
+ rrcMsgType = RRC_SETUP;
+ break;
+ case RRC_SETUP_COMPLETE:
+ rrcMsgType = RRC_SETUP_COMPLETE;
+ break;
case SECURITY_MODE_COMPLETE:
- rrcMsgType = SECURITY_MODE_COMPLETE;
- break;
- case RRC_RECONFIG:
- rrcMsgType = RRC_RECONFIG;
- break;
- case UE_CONTEXT_MOD_REQ:
- rrcMsgType = UE_CONTEXT_MOD_REQ;
- break;
+ rrcMsgType = SECURITY_MODE_COMPLETE;
+ break;
+ case REGISTRATION_COMPLETE:
+ rrcMsgType = REGISTRATION_COMPLETE;
+ break;
+ case UE_CONTEXT_SETUP_RSP:
+ rrcMsgType = UE_CONTEXT_SETUP_RSP;
+ break;
+ case RRC_RECONFIG_COMPLETE:
+ rrcMsgType = RRC_RECONFIG_COMPLETE;
+ break;
default:
- break;
+ break;
}
return rrcMsgType;
}
/*******************************************************************
*
- * @brief Function to build Initial UL RRC Message
+ * @brief Extract configuration from CellGroupConfig
*
* @details
*
- * Function : procInitULRRCMsg
+ * Function : extractCellGroupConfig
*
- * Functionality: Function to build Initial UL RRC Message
+ * Functionality: Extract configuration from CellGroupConfig
+ * and store in local database
*
- * @params[in]
+ * @params[in] UE control block
+ * Cell Group Config
*
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-
-uint8_t procInitULRRCMsg(F1AP_PDU_t *f1apMsg)
+uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
{
- uint8_t idx, rrcMsgType, gnbDuUeF1apId;
- uint8_t ret =ROK;
- InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
- DU_LOG("\nINFO --> F1AP : filling the required values in DB in procInitULRRCMsg");
+ uint8_t rbIdx, srbIdx, drbIdx;
+ bool srbFound, drbFound;
+ SrbInfo *srbCfgDb = NULLP;
+ DrbInfo *drbCfgDb = NULLP;
+ RlcLcCfg *rlcLcCfgDb = NULLP;
+ MacLcCfg *macLcCfgDb = NULLP;
+ RLC_BearerConfig_t *rlcCfg = NULLP;
+ RLC_Config_t *rlcLcCfg = NULLP;
+ LogicalChannelConfig_t *macLcCfg = NULLP;
- initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
+ if(ueCb == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP: extractCellGroupConfig(): UE Cb is NULL");
+ return RFAILED;
+ }
- for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
+ if(cellGrpCfg == NULLP)
{
- switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
+ DU_LOG("\nERROR --> F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
+ return RFAILED;
+ }
+
+ for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
+ {
+ srbFound = false;
+ drbFound = false;
+
+ rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
+
+ /* Update SRB configuration in local DB */
+ if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
{
- case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
- gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
- break;
- case ProtocolIE_ID_id_NRCGI:
- break;
- case ProtocolIE_ID_id_C_RNTI:
- break;
- case ProtocolIE_ID_id_RRCContainer:
- break;
- case ProtocolIE_ID_id_DUtoCURRCContainer:
+ /* Search if SRB entry is already present in DB */
+ for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
+ {
+ if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
{
- if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice\
- .DUtoCURRCContainer.size > 0) && (initULRRCMsg->protocolIEs\
- .list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
- {
- DU_LOG("\nINFO --> Received Du to Cu RRC Container ");
- ueCb[gnbDuUeF1apId-1].ueId = gnbDuUeF1apId;
- ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs\
- .list.array[idx]->value.choice.DUtoCURRCContainer.size;
- CU_ALLOC(ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.buf, \
- ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.size);
- if(ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.buf != NULLP)
- {
- memcpy(ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.buf, initULRRCMsg->protocolIEs\
- .list.array[idx]->value.choice.DUtoCURRCContainer.buf, ueCb[gnbDuUeF1apId-1].f1apMsgDb\
- .duToCuContainer.size);
- }
- }
- else
- {
+ srbCfgDb = &ueCb->srbList[srbIdx];
+ srbFound = true;
+ break;
+ }
+ }
+
+ /* If not, add SRB to UE CB's SRB list */
+ if(!srbFound)
+ {
+ ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
+ srbCfgDb = &ueCb->srbList[ueCb->numSrb];
+ ueCb->numSrb++;
+ }
+
+ srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
+ srbCfgDb->cfgSentToUe = false;
+ rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
+ macLcCfgDb = &srbCfgDb->macLcCfg;
+ }
+
+ /* Update DRB configuration in local DB */
+ if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
+ {
+ /* Search if DRB entry is already present in DB */
+ for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
+ {
+ if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
+ {
+ drbCfgDb = &ueCb->drbList[drbIdx];
+ drbFound = true;
+ break;
+ }
+ }
+
+ /* If not, add DRB to UE CB's SRB list */
+ if(!drbFound)
+ {
+ ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
+ drbCfgDb = &ueCb->drbList[ueCb->numDrb];
+ ueCb->numDrb++;
+ }
+
+ drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
+ drbCfgDb->cfgSentToUe = false;
+ rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
+ macLcCfgDb = &drbCfgDb->macLcCfg;
+ }
+
+
+ /* Update RLC configuration for this RB */
+ rlcLcCfg = rlcCfg->rlc_Config;
+ rlcLcCfgDb->rlcMode = rlcLcCfg->present;
+ switch(rlcLcCfgDb->rlcMode)
+ {
+ case RLC_Config_PR_am:
+ {
+ rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
+ rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
+ rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
+ rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
+ rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
+
+ rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
+ rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
+ rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
+ break;
+ }
+
+ case RLC_Config_PR_um_Bi_Directional:
+ {
+ rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
+
+ rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
+ rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
+ break;
+ }
+ }
+
+ /* Update MAC configuration for this LC */
+ macLcCfg = rlcCfg->mac_LogicalChannelConfig;
+ macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
+ macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
+ macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
+ macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
+ macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Function to decode DU to CU RRC container
+ *
+ * @details
+ *
+ * Function : extractDuToCuRrcCont
+ *
+ * Functionality: Function to decode DU to CU RRC container
+ *
+ * @params[in] UE Cb
+ * RRC conatiner octect string to be decoded
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
+{
+ CellGroupConfigRrc_t cellGrpCfg, *cellGrpCfgMsg = NULLP;
+ asn_dec_rval_t rval; /* Decoder return value */
+
+ /* Copy the received container to UeCb */
+ memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
+
+ /* Decoding DU to CU RRC container octet string to cell group config */
+ cellGrpCfgMsg = &cellGrpCfg;
+ memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
+
+ rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
+
+ if(rval.code == RC_FAIL || rval.code == RC_WMORE)
+ {
+ DU_LOG("\nERROR --> F1AP : ASN decode failed");
+ return RFAILED;
+ }
+ printf("\n");
+ xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
+
+ if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract cell group config");
+ return RFAILED;
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Function to build Initial UL RRC Message
+ *
+ * @details
+ *
+ * Function : procInitULRRCMsg
+ *
+ * Functionality: Function to build Initial UL RRC Message
+ *
+ * @params[in]
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
+{
+ uint8_t idx = 0, duIdx=0, rrcMsgType=0, gnbDuUeF1apId=0;
+ uint8_t ret =ROK;
+ uint16_t cellIdx=0, nrCellId = 0;
+ uint32_t crnti;
+ DuDb *duDb;
+ CuCellCb *cellCb;
+ CuUeCb *ueCb;
+ InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
+
+ DU_LOG("\nINFO --> F1AP : filling the required values in DB in procInitULRRCMsg");
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
+
+ for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
+ {
+ switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
+ {
+ case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
+ gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
+ break;
+
+ case ProtocolIE_ID_id_NRCGI:
+ bitStringToInt(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
+ SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
+ if(cellCb == NULLP)
+ return RFAILED;
+ break;
+
+ case ProtocolIE_ID_id_C_RNTI:
+ crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
+ if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
+ {
+ ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
+ memset(ueCb, 0, sizeof(CuUeCb));
+ ueCb->cellCb = cellCb;
+ ueCb->crnti = crnti;
+ ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
+ ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
+ ueCb->state = UE_ATTACH_IN_PROGRESS;
+ (duDb->numUe)++;
+
+ cellCb->ueCb[cellCb->numUe] = ueCb;
+ cellCb->numUe++;
+ }
+ break;
+
+ case ProtocolIE_ID_id_RRCContainer:
+ break;
+
+ case ProtocolIE_ID_id_DUtoCURRCContainer:
+ {
+ if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
+ (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
+ {
+ DU_LOG("\nINFO --> Received Du to Cu RRC Container ");
+ ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
+ CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
+ if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
+ {
+ memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
+ initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
+ ueCb->f1apMsgDb.duToCuContainer.size);
+ }
+ if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract DU to CU RRC Container ");
+ ret = RFAILED;
+ }
+ }
+ else
+ {
DU_LOG("\nERROR --> Failed to receive Du to Cu RRC Container ");
ret = RFAILED;
}
break;
}
+
default:
DU_LOG("\nERROR --> Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
break;
}
+ if(ret == RFAILED)
+ break;
}
+
if(ret == ROK)
{
- ueCb[gnbDuUeF1apId-1].f1apMsgDb.dlRrcMsgCount++;
- rrcMsgType = setDlRRCMsgType(gnbDuUeF1apId);
- ret = BuildAndSendDLRRCMessageTransfer(gnbDuUeF1apId, SRB0, rrcMsgType);
+ ueCb->f1apMsgDb.dlRrcMsgCount++;
+ rrcMsgType = setDlRRCMsgType(ueCb);
+ ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
}
return ret;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildNrcgi(NRCGI_t *nrcgi)
+uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
{
uint8_t ret;
uint8_t unused_bits = 4;
uint8_t byteSize = 5;
- uint8_t val = 16;
+
/* Allocate Buffer Memory */
nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
{
return RFAILED;
}
- ret = buildPlmnId(cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
+ ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
if(ret != ROK)
{
{
return RFAILED;
}
- fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, val);
+ fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
+uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
{
uint8_t cellCnt;
uint8_t idx;
idx = 0;
spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
spCellLst->list.array[idx]->criticality = Criticality_ignore;
- spCellLst->list.array[idx]->value.present =\
- SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
+ spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
+
/* Special Cell ID -NRCGI */
- ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
+ ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
if(ret != ROK)
{
return RFAILED;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
+uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
{
uint8_t idx;
uint8_t srbCnt;
- srbCnt = 1;
+
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ srbCnt = ueCb->numSrb;
+ else
+ srbCnt = 1;
srbSet->list.count = srbCnt;
srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
CU_ALLOC(srbSet->list.array,srbSet->list.size);
if(srbSet->list.array == NULLP)
{
+ DU_LOG("\nERROR --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
return RFAILED;
}
+
for(idx=0; idx<srbCnt; idx++)
{
CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
if(srbSet->list.array[idx] == NULLP)
{
- return RFAILED;
+ DU_LOG("\nERROR --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
+ return RFAILED;
+ }
+ }
+
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ {
+ idx = 0;
+ srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
+ srbSet->list.array[idx]->criticality = Criticality_ignore;
+ srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
+ srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
+ ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
+ ueCb->numSrb++;
+ }
+ else
+ {
+ for(idx=0; idx<srbCnt; idx++)
+ {
+ srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
+ srbSet->list.array[idx]->criticality = Criticality_ignore;
+ srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
+ srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
}
}
- idx = 0;
- srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
- srbSet->list.array[idx]->criticality = Criticality_ignore;
- srbSet->list.array[idx]->value.present = \
- SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
- srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
return ROK;
}/* End of BuildSRBSetup*/
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, \
- int16_t pduSessionID)
+uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
{
uint8_t elementCnt = 0, qosCntIdx = 0;
ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
{
return RFAILED;
}
- /*FiveQI*/
- if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
- drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
+
+ if(hoInProgress)
+ drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
else
- drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
-
- /*AveragingWindow*/
- CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
- sizeof(AveragingWindow_t));
- if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
- NULLP)
{
- return RFAILED;
+ /*FiveQI*/
+ if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
+ drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
+ else
+ drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
+
+ qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
}
- *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
- /*MaxDataBurstVolume*/
- CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
- sizeof(MaxDataBurstVolume_t));
- if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
- NULLP)
+
+ if(!hoInProgress)
{
- return RFAILED;
+ /*AveragingWindow*/
+ CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
+ if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
+ {
+ return RFAILED;
+ }
+ *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
+ qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
+
+ /*MaxDataBurstVolume*/
+ CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
+ if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
+ {
+ return RFAILED;
+ }
+ *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
+ qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
}
- *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
/*nRGRAN Allocation Retention Priority*/
- drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
- drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
- drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
-
- /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
- if(pduSessionID <= INVALID_PDU_SESSION_ID)
+ if(hoInProgress)
{
- DU_LOG("\nINFO --> F1AP : Invalid PDU_SESSION_ID");
- return ROK;
+ drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
+ drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
+ drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
}
-
- CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
- qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
-
- if(qosIeExt)
+ else
{
- elementCnt = NUM_QOS_EXT;
- qosIeExt->list.count = elementCnt;
- qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
+ drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
+ drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
+ drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
- /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
- CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
+ qosInfo->priorityLevel = PriorityLevel_lowest;
+ qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
+ qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
+ }
- if(qosIeExt->list.array == NULLP)
+ /* PDU session ID */
+ if(!hoInProgress)
+ {
+ /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
+ if(pduSessionID <= INVALID_PDU_SESSION_ID)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
- return RFAILED;
+ DU_LOG("\nINFO --> F1AP : Invalid PDU_SESSION_ID");
+ return ROK;
}
- for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
+ CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
+ qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
+
+ if(qosIeExt)
{
- CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
- if(qosIeExt->list.array[qosCntIdx] == NULLP)
+ elementCnt = NUM_QOS_EXT;
+ qosIeExt->list.count = elementCnt;
+ qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
+
+ /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
+ CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
+
+ if(qosIeExt->list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
+ DU_LOG("\nERROR --> F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
return RFAILED;
}
- /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
- qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
- /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
- qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
- qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
- QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
- qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
+
+ for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
+ {
+ CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
+ if(qosIeExt->list.array[qosCntIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
+ return RFAILED;
+ }
+ /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
+ qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
+ /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
+ qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
+ qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
+ QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
+ qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
+ qosInfo->pduSessionId = pduSessionID;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for QosIE_extension failed");
+ return RFAILED;
}
}
- else
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation for QosIE_extension failed");
- return RFAILED;
- }
-
return ROK;
}/*End of BuildQOSInfo*/
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildSNSSAI(SNSSAI_t *snssai, Snssai *snssaiToCopy)
+uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
{
/*SNSSAI*/
/*ssT*/
snssai->sST.size = sizeof(uint8_t);
- CU_ALLOC(snssai->sST.buf,snssai->sST.size);
+ CU_ALLOC(snssai->sST.buf, snssai->sST.size);
if(snssai->sST.buf == NULLP)
{
return RFAILED;
}
- memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
+ if(!hoInProgress)
+ memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
+ else
+ memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
+
/*sD*/
- CU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
+ CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
if(snssai->sD == NULLP)
{
return RFAILED;
}
- snssai->sD->size = 3*sizeof(uint8_t);
- CU_ALLOC(snssai->sD->buf,snssai->sD->size);
+ snssai->sD->size = 3 * sizeof(uint8_t);
+ CU_ALLOC(snssai->sD->buf, snssai->sD->size);
if(snssai->sD->buf == NULLP)
{
return RFAILED;
}
- memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
+ if(!hoInProgress)
+ memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
+ else
+ memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
+
+ if(!hoInProgress)
+ drbInfo->snssai = snssaiToCopy;
return ROK;
}/*End of BuildSNSSAI*/
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType)
+uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
{
- uint8_t ret = ROK, idx = 0, flowCnt = 0;
+ uint8_t ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
+ FlowsMapped *qosFlow;
- flowCnt = 1;
+ if(!hoInProgress)
+ flowCnt = 1;
+ else
+ flowCnt = drbInfo->numFlowMap;
flowMap->list.count = flowCnt;
flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
CU_ALLOC(flowMap->list.array,flowMap->list.size);
DU_LOG("\nERROR --> F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
return RFAILED;
}
- }
- idx = 0;
- flowMap->list.array[idx]->qoSFlowIdentifier = 0;
- ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
- actionType, INVALID_PDU_SESSION_ID);
- if(ret != ROK)
- {
- DU_LOG("\nERROR --> F1AP : Failed to Build QOS Info in BuildFlowsMap()");
- return RFAILED;
+
+ if(!hoInProgress)
+ {
+ flowMap->list.array[idx]->qoSFlowIdentifier = 0;
+ if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
+ {
+ for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
+ {
+ if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
+ {
+ qosFlow = &drbInfo->flowMapList[flowIdx];
+ break;
+ }
+ }
+ }
+ else
+ {
+ qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
+ qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
+ }
+ }
+ else
+ {
+ qosFlow = &drbInfo->flowMapList[idx];
+ flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
+ }
+
+ ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
+ actionType, INVALID_PDU_SESSION_ID, hoInProgress);
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to Build QOS Info in BuildFlowsMap()");
+ return RFAILED;
+ }
+
+ if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
+ drbInfo->numFlowMap++;
}
return ROK;
}/*End of BuildFlowsMap*/
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
+uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
{
uint8_t idx;
uint8_t ulCnt;
+
ulCnt = 1;
ulInfo->list.count = ulCnt;
ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
}
}
idx = 0;
- ulInfo->list.array[idx]->uLUPTNLInformation.present = \
- UPTransportLayerInformation_PR_gTPTunnel;
+ ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
/*GTP TUNNEL*/
- CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
- sizeof(GTPTunnel_t));
+ CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
{
DU_LOG("\nERROR --> F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
return RFAILED;
}
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- transportLayerAddress.size = 4*sizeof(uint8_t);
- CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- transportLayerAddress.buf,ulInfo->list.array[idx]->\
- uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
- if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- transportLayerAddress.buf == NULLP)
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size = 4*sizeof(uint8_t);
+ CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
+ if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
{
DU_LOG("\nERROR --> F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
return RFAILED;
}
- /* NOTE: Below IP address must be changed if running on different IP configuration */
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- transportLayerAddress.buf[0] = 192;
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- transportLayerAddress.buf[1] = 168;
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- transportLayerAddress.buf[2] = 130;
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- transportLayerAddress.buf[3] = 82;
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- transportLayerAddress.bits_unused = 0;
+
+ if(!hoInProgress)
+ {
+ /* NOTE: Below IP address must be changed if running on different IP configuration */
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
+
+ ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
+ ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
+ ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
+ ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
+ }
+ else
+ {
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
+ }
+
/*GTP TEID*/
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
- = 4 * sizeof(uint8_t);
- CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
- gTPTunnel->gTP_TEID.size);
- if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
- == NULLP)
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
+ CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
+ if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
{
DU_LOG("\nERROR --> F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
return RFAILED;
}
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- gTP_TEID.buf[0] = 0;
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- gTP_TEID.buf[1] = 0;
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- gTP_TEID.buf[2] = 0;
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- gTP_TEID.buf[3] = cuCfgParams.egtpParams.currTunnelId++;
+
+ if(!hoInProgress)
+ {
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
+ ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
+ ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
+ ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
+ ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
+ }
+ else
+ {
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
+ }
return ROK;
}/*End of BuildULTnlInfo*/
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
+uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
{
- uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0, idx = 0;
- uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0, drbCnt = 0;
+ uint16_t snssaiIdx=0;
+ uint8_t idx = 0, extIeIdx = 0;
+ uint8_t elementCnt = 0, drbCnt = 0;
+ uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
+ uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
DRBs_ToBeSetup_Item_t *drbSetItem;
+ ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
+ DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
- drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ drbCnt = ueCb->numDrb;
+ else
+ drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
drbSet->list.count = drbCnt;
+
drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
CU_ALLOC(drbSet->list.array,drbSet->list.size);
if(drbSet->list.array == NULLP)
DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDRBSetup");
return RFAILED;
}
+
for(idx=0; idx<drbCnt; idx++)
{
CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
if(drbSet->list.array[idx] == NULLP)
{
DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
- return RFAILED;
+ return RFAILED;
}
drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
drbSet->list.array[idx]->criticality = Criticality_ignore;
- drbSet->list.array[idx]->value.present = \
- DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
+ drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
/*dRBID*/
- drbSetItem->dRBID = idx + 1;
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ {
+ drbSetItem->dRBID = idx + 1;
+ ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
+ }
+ else
+ drbSetItem->dRBID = ueCb->drbList[idx].drbId;
+
/*qoSInformation*/
drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
DU_LOG("\nERROR --> F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
return RFAILED;
}
- drbSetItem->qoSInformation.choice.choice_extension->id = \
- ProtocolIE_ID_id_DRB_Information;
- drbSetItem->qoSInformation.choice.choice_extension->criticality = \
- Criticality_ignore;
- drbSetItem->qoSInformation.choice.choice_extension->value.present = \
- QoSInformation_ExtIEs__value_PR_DRB_Information;
- BuildQOSInforet = BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
- choice_extension->value.choice.DRB_Information.dRB_QoS,\
- ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1);
+ drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
+ drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
+ drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ BuildQOSInforet = BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
+ choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
+ else
+ BuildQOSInforet = BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
+ choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
if(BuildQOSInforet != ROK)
{
DU_LOG("\nERROR --> F1AP : Failed to build QOS Info in BuildDRBSetup");
return RFAILED;
}
+
/*SNSSAI*/
- BuildSNSSAIret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
- choice_extension->value.choice.DRB_Information.sNSSAI, cuCfgParams.snssaiList[0]);
+ snssaiIdx = (idx% cuCb.numSnssaiSupported);
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
+ choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[snssaiIdx], FALSE);
+ else
+ BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
+ choice_extension->value.choice.DRB_Information.sNSSAI, NULLP, TRUE);
if(BuildSNSSAIret != ROK)
{
DU_LOG("\nERROR --> F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
return RFAILED;
}
+
/*Flows mapped to DRB List*/
- BuildFlowsMapret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
- choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
- ProtocolIE_ID_id_DRBs_ToBeSetup_Item);
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
+ value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
+ else
+ BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
+ value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
if(BuildFlowsMapret != ROK)
{
DU_LOG("\nERROR --> F1AP : Failed to build Flow Map Info in BuildDRBSetup");
return RFAILED;
}
+
/*ULUPTNLInformation To Be Setup List*/
- BuildULTnlInforet = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
+ FALSE);
+ else
+ BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
+ TRUE);
if(BuildULTnlInforet != ROK)
{
DU_LOG("\nERROR --> F1AP : Failed to build tunnel Info in BuildDRBSetup");
return RFAILED;
}
+
/*RLCMode*/
- drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
- }
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ {
+ drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
+ ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
+ }
+ else
+ drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
+
+ /* DL PDCP SN Length */
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ {
+ CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
+ if(!drbToBeSetupExt)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
+ return RFAILED;
+ }
+
+ elementCnt = 1;
+ drbToBeSetupExt->list.count = elementCnt;
+ drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
+
+ CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
+ if(!drbToBeSetupExt->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
+ return RFAILED;
+ }
+
+ for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
+ {
+ CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
+ if(!drbToBeSetupExt->list.array[extIeIdx])
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
+ return RFAILED;
+ }
+ }
+
+ extIeIdx = 0;
+ drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
+
+ drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
+ drbToBeSetupExtIe->criticality = Criticality_ignore;
+ drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
+ drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
+ drbSetItem->iE_Extensions = drbToBeSetupExt;
+ }
+
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ ueCb->numDrb++;
+ }
return ROK;
}/* End of BuildDRBSetup*/
ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
}
break;
+ case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
+ CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
+ ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
+ break;
default:
DU_LOG("\nERROR --> F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
break;
resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
= SRS_CYCLIC_SHIFT_N2;
- resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
- 0;
+ resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols = \
SRS_Resource__resourceMapping__nrofSymbols_n1;
resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
if(!tagList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
- return RFAILED;
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ return RFAILED;
}
}
CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
if(!schReqList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
- return RFAILED;
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ return RFAILED;
}
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
+uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
{
+ rlcConfig->present = rlcLcCfgDb.rlcMode;
- rlcConfig->present = RLC_Config_PR_am;
-
- rlcConfig->choice.am = NULLP;
- CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
- if(!rlcConfig->choice.am)
+ switch(rlcConfig->present)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
- return RFAILED;
- }
+ case RLC_Config_PR_am:
+ {
+ rlcConfig->choice.am = NULLP;
+ CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
+ if(!rlcConfig->choice.am)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
- /* UL */
- rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
- CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
- if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
- return RFAILED;
- }
- *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
- 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;
- rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold = MAX_RETX_THRESHOLD;
+ /* UL */
+ rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
+ CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+ *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
+ rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
+ rlcConfig->choice.am->ul_AM_RLC.pollPDU = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
+ rlcConfig->choice.am->ul_AM_RLC.pollByte = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
+ rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
+
+ /* DL */
+ rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
+ CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+ *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
+ rlcConfig->choice.am->dl_AM_RLC.t_Reassembly = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
+ rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
- /* DL */
- rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
- CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
- if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
- return RFAILED;
- }
- *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
- rlcConfig->choice.am->dl_AM_RLC.t_Reassembly = T_REASSEMBLY;
- rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit = T_STATUS_PROHIBHIT;
+ break;
+ }
+
+ case RLC_Config_PR_um_Bi_Directional:
+ {
+ rlcConfig->choice.um_Bi_Directional = NULLP;
+ CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
+ if(!rlcConfig->choice.um_Bi_Directional)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+
+ /* UL */
+ rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
+ CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
+ if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+ *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
+ /* DL */
+ rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
+ CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
+ if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+ *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
+ rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
+ break;
+ }
+ }
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
+uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
{
macLcConfig->ul_SpecificParameters = NULLP;
return RFAILED;
}
- macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
- macLcConfig->ul_SpecificParameters->prioritisedBitRate = PRIORTISIED_BIT_RATE;
- macLcConfig->ul_SpecificParameters->bucketSizeDuration = BUCKET_SIZE_DURATION;
+ macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
+ macLcConfig->ul_SpecificParameters->prioritisedBitRate = macLcCfgDb.pbr;
+ macLcConfig->ul_SpecificParameters->bucketSizeDuration = macLcCfgDb.bsd;
macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
- *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
+ *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
return RFAILED;
}
- *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
+ *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
+uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
{
- uint8_t idx, elementCnt;
+ uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
- elementCnt = 1;
+ if(updateAllRbCfg)
+ elementCnt = ueCb->numSrb + ueCb->numDrb;
+ else
+ {
+ for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
+ {
+ if(ueCb->srbList[srbIdx].cfgSentToUe == false)
+ elementCnt++;
+ }
+
+ for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
+ {
+ if(ueCb->drbList[drbIdx].cfgSentToUe == false)
+ elementCnt++;
+ }
+ }
+
+ if(!elementCnt)
+ {
+ DU_LOG("INFO --> F1AP : No RLC Bearer available to add or modify");
+ return ROK;
+ }
+ CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
+ if(!rlcBearerList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in CellGrpConfig");
+ return RFAILED;
+ }
rlcBearerList->list.count = elementCnt;
rlcBearerList->list.size = elementCnt * sizeof(struct RLC_BearerConfig *);
CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
if(!rlcBearerList->list.array[idx])
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
- return RFAILED;
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
}
}
idx = 0;
- rlcBearerList->list.array[idx]->logicalChannelIdentity = RLC_LCID;
- CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
- if(!rlcBearerList->list.array[idx]->servedRadioBearer)
+ for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
- return RFAILED;
- }
+ if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
+ continue;
- rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
- rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB_ID_1;
+ rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
- rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
- rlcBearerList->list.array[idx]->rlc_Config = NULLP;
- CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
- if(!rlcBearerList->list.array[idx]->rlc_Config)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
- return RFAILED;
- }
+ CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
+ if(!rlcBearerList->list.array[idx]->servedRadioBearer)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
- if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
- {
- DU_LOG("\nERROR --> F1AP : BuildRlcConfig failed");
- return RFAILED;
- }
+ rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
+ rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
- rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
- CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
- if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
- return RFAILED;
+ rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
+ rlcBearerList->list.array[idx]->rlc_Config = NULLP;
+ CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
+ if(!rlcBearerList->list.array[idx]->rlc_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildRlcConfig failed");
+ return RFAILED;
+ }
+
+ rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
+ CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
+ if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildMacLCConfig failed");
+ return RFAILED;
+ }
+ idx++;
}
- if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
+ for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
{
- DU_LOG("\nERROR --> F1AP : BuildMacLCConfig failed");
- return RFAILED;
- }
+ if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
+ continue;
+
+ rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
+
+ CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
+ if(!rlcBearerList->list.array[idx]->servedRadioBearer)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
+ rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
+
+ rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
+ rlcBearerList->list.array[idx]->rlc_Config = NULLP;
+ CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
+ if(!rlcBearerList->list.array[idx]->rlc_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildRlcConfig failed");
+ return RFAILED;
+ }
+
+ rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
+ CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
+ if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+ if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildMacLCConfig failed");
+ return RFAILED;
+ }
+ idx++;
+ }
return ROK;
}
*
******************************************************************/
-uint8_t fillCellGrpCfg(CellGroupConfig_t *cellGrp)
+uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
{
uint8_t ret = RFAILED;
CellGroupConfigRrc_t cellGrpCfg;
cellGrpCfg.cellGroupId = CELL_GRP_ID;
cellGrpCfg.rlc_BearerToAddModList = NULLP;
- CU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
- if(!cellGrpCfg.rlc_BearerToAddModList)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in CellGrpConfig");
- break;
- }
- if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
+
+ if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
{
- DU_LOG("\nERROR --> F1AP : fillCellGrpCfg failed");
- break;
+ DU_LOG("\nERROR --> F1AP : fillCellGrpCfg failed");
+ break;
}
cellGrpCfg.rlc_BearerToReleaseList = NULLP;
CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
if(!cellGrpCfg.mac_CellGroupConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in fillCellGrpCfg");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in fillCellGrpCfg");
+ break;
}
if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildMacCellGrpCfg failed");
- break;
+ DU_LOG("\nERROR --> F1AP : BuildMacCellGrpCfg failed");
+ break;
}
-
cellGrpCfg.physicalCellGroupConfig = NULLP;
CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
if(!cellGrpCfg.physicalCellGroupConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ break;
}
if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildPhyCellGrpCfg failed");
- break;
+ DU_LOG("\nERROR --> F1AP : BuildPhyCellGrpCfg failed");
+ break;
}
cellGrpCfg.spCellConfig = NULLP;
CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
if(!cellGrpCfg.spCellConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ break;
}
if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
{
- DU_LOG("\nERROR --> F1AP : BuildSpCellCfg failed");
- break;
+ DU_LOG("\nERROR --> F1AP : BuildSpCellCfg failed");
+ break;
}
cellGrpCfg.sCellToAddModList = NULLP;
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG( "\nERROR --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- break;
+ DU_LOG( "\nERROR --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
- for(int i=0; i< encBufSize; i++)
- {
- DU_LOG("%x",encBuf[i]);
- }
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
}
cellGrp->size = encBufSize;
CU_ALLOC(cellGrp->buf, cellGrp->size);
if(!cellGrp->buf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
+ break;
}
memcpy(cellGrp->buf, encBuf, cellGrp->size);
ret = ROK;
break;
}
FreeMemCellGrpCfg(&cellGrpCfg);
- return ROK;
+ return ret;
}
/*******************************************************************
}
}
+/*******************************************************************
+ *
+ * @brief Free Handover preparation information
+ *
+ * @details
+ *
+ * Function : freeHOPreparationInfo
+ *
+ * Functionality: Free Handover preparation information
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
+{
+ HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
+
+ if(hoPrep->criticalExtensions.choice.c1)
+ {
+ if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
+ {
+ hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
+ freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
+ CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
+ sizeof(HandoverPreparationInformationRrc_IEs_t));
+ }
+ CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
+ }
+}
+
/*******************************************************************
*
* @brief Fill feature sets
* Functionality: Fill UE Capability RAT container list
*
- * @params[in] UE capability RAT container list buffer
+ * @params[in] UE capability RAT container list
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
+uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
{
uint8_t ret = RFAILED;
uint8_t idx, elementCnt;
- asn_enc_rval_t encRetVal;
- UE_CapabilityRAT_ContainerListRRC_t ueCapablityList;
while(true)
{
elementCnt = 1;
- ueCapablityList.list.count = elementCnt;
- ueCapablityList.list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
+ ueCapablityList->list.count = elementCnt;
+ ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
- CU_ALLOC(ueCapablityList.list.array, ueCapablityList.list.size);
- if(!ueCapablityList.list.array)
+ CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
+ if(!ueCapablityList->list.array)
{
DU_LOG("\nERROR --> Memory allocation failed in fillUeCapRatContList");
- ret = RFAILED;
- break;
+ ret = RFAILED;
+ break;
}
for(idx=0; idx<elementCnt; idx++)
{
- CU_ALLOC(ueCapablityList.list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
- if(ueCapablityList.list.array[idx] == NULLP)
+ CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
+ if(ueCapablityList->list.array[idx] == NULLP)
{
- DU_LOG("\nERROR --> Memory allocation failed in fillUeCapRatContList");
+ DU_LOG("\nERROR --> Memory allocation failed in fillUeCapRatContList");
ret = RFAILED;
- break;
+ break;
}
}
idx = 0;
- ueCapablityList.list.array[idx]->rat_Type = RAT_Type_nr;
- ret = fillUeCapRatCont(&ueCapablityList.list.array[idx]->ue_CapabilityRAT_Container);
-
- /* encode UE Capability RAT Container List into duToCuRrcContainer */
- xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
- encBufSize = 0;
- encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
- &ueCapablityList, PrepFinalEncBuf, encBuf);
-
- /* Encode results */
- if(encRetVal.encoded == ENCODE_FAIL)
- {
- DU_LOG( "\nERROR --> F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- break;
- }
- else
- {
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
- for(int i=0; i< encBufSize; i++)
- {
- DU_LOG("%x",encBuf[i]);
- }
- }
-
- ueCapablityListBuf->size = encBufSize;
- CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
- if(!ueCapablityListBuf->buf)
+ ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
+ if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
+ DU_LOG("\nERROR --> F1AP : Failed to fill UE capability RAT Conatiner");
+ ret = RFAILED;
break;
}
- memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
+
ret = ROK;
break;
}
- freeUeCapRatContList(&ueCapablityList);
- return ROK;
+ return ret;
}
/*******************************************************************
*
- * @brief Fills CuToDuContainer
+ * @brief Fill UE Capability RAT container list octet string
*
* @details
*
- * Function : fillCuToDuContainer
- *
- * Functionality: Fills CuToDuContainer
+ * Function : fillUeCapRatContListBuf
*
- * @params[in] pointer to CUtoDURRCInformation_t
+ * Functionality: Fill UE Capability RAT container list octet string
+
*
+ * @params[in] UE capability RAT container list buffer
* @return ROK - success
* RFAILED - failure
*
- ******************************************************************/
-
-uint8_t fillCuToDuContainer(CUtoDURRCInformation_t *rrcMsg)
+ * ****************************************************************/
+uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
{
- uint8_t elementCnt = 0;
- uint8_t ret = ROK;
- uint8_t idx, idx2, rrcBufLen;
-
- CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
- if(!rrcMsg->uE_CapabilityRAT_ContainerList)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
- return RFAILED;
- }
- ret = fillUeCapRatContList(rrcMsg->uE_CapabilityRAT_ContainerList);
+ uint8_t ret = RFAILED;
+ asn_enc_rval_t encRetVal;
+ UE_CapabilityRAT_ContainerListRRC_t ueCapablityList;
- CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
- if(rrcMsg->iE_Extensions)
+ while(true)
{
- elementCnt = 1;
- rrcMsg->iE_Extensions->list.count = elementCnt;
- rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t);
+ ret = fillUeCapRatContList(&ueCapablityList);
+ if(ret != ROK)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to fill UE Capability RAT container list");
+ break;
+ }
- /* Initialize the CUtoDURRCInformation_ExtIEs */
- CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
+ /* encode UE Capability RAT Container List into duToCuRrcContainer */
+ xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
+ &ueCapablityList, PrepFinalEncBuf, encBuf);
- if(rrcMsg->iE_Extensions->list.array == NULLP)
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
- ret = RFAILED;
+ DU_LOG( "\nERROR --> F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
}
-
- for(idx=0; idx<elementCnt; idx++)
+ else
{
- CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
- if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
- {
- ret = RFAILED;
- }
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
}
- idx = 0;
- /* Filling CellGroupConfig_t IE */
- rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
- rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
- rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present =\
- CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
- ret = fillCellGrpCfg(&rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig);
- }
- return ret;
-}
+
+ ueCapablityListBuf->size = encBufSize;
+ CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
+ if(!ueCapablityListBuf->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
+ break;
+ }
+ memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
+ ret = ROK;
+ break;
+ }
+ freeUeCapRatContList(&ueCapablityList);
+ return ret;
+}
/*******************************************************************
*
- * @brief Free CuToDuContainer
+ * @brief Free Measurement Timing Configuration
*
* @details
*
- * Function : FreeCuToDuInfo
- *
- * Functionality: Free CuToDuContainer
+ * Function : freeMeasuementTimingConfig
*
- * @params[in] pointer to CUtoDURRCInformation_t
+ * Functionality: Free Measurement Timing Configuration
*
- * @return ROK - success
- * RFAILED - failure
+ * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
+ * @return void
*
- ******************************************************************/
-
-void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
+ * ****************************************************************/
+void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
{
- uint8_t idx, idx2;
+ uint8_t measCfgIdx;
+ MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
+ MeasTiming_t *measTiming = NULLP;
- if(rrcMsg->uE_CapabilityRAT_ContainerList)
+ if(measTimingConfig.criticalExtensions.choice.c1)
{
- if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
- CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
- CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
- }
- if(rrcMsg->iE_Extensions)
- {
- if(rrcMsg->iE_Extensions->list.array)
+ if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
{
- for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
- {
- if(rrcMsg->iE_Extensions->list.array[idx])
- {
- switch(rrcMsg->iE_Extensions->list.array[idx]->id)
- {
- case ProtocolIE_ID_id_CellGroupConfig:
- if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
- {
- CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
- rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
-
- }
- break;
- default:
- DU_LOG("\nERROR --> F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
- rrcMsg->iE_Extensions->list.array[idx]->id);
- break;
- }
- }
- break;
- }
- for(idx2 = 0; idx2 < idx; idx2++)
- {
- CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
- }
- CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
-
+ measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
+ if(measTimingCfg->measTiming)
+ {
+ if(measTimingCfg->measTiming->list.array)
+ {
+ for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
+ {
+ measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
+ CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
+ CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
+ }
+ CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
+ }
+ CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
+ }
+ CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
}
-
- CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
+ CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
}
}
+
/*******************************************************************
*
- * @brief Builds and sends the UE Setup Request
+ * @brief Fill Measurement Timing Configuration
*
* @details
*
- * Function : BuildAndSendUeContextSetupReq
- *
- * Functionality: Constructs the UE Setup Request and sends
- * it to the CU through SCTP.
+ * Function : fillMeasTimingCfg
*
- * @params[in]
+ * Functionality: Fill Measurement Timing Configuration
*
+ * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendUeContextSetupReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \
- uint16_t rrcContLen, uint8_t *rrcContainer)
+uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
{
- uint8_t Nrcgiret;
- uint8_t SplCellListret;
- uint8_t SrbSetupret;
- uint8_t elementCnt;
- uint8_t idx, bufLen;
- uint8_t idx1;
- F1AP_PDU_t *f1apMsg = NULLP;
- UEContextSetupRequest_t *ueSetReq = NULLP;
- asn_enc_rval_t encRetVal; /* Encoder return value */
- memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
- uint8_t ret= RFAILED;
- uint8_t ret1;
- while(true)
- {
- DU_LOG("\nINFO --> F1AP : Building UE Context Setup Request\n");
-
- CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
- if(f1apMsg == NULLP)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
- break;
- }
-
- f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
- CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
- if(f1apMsg->choice.initiatingMessage == NULLP)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
- break;
- }
-
- f1apMsg->choice.initiatingMessage->procedureCode = \
- ProcedureCode_id_UEContextSetup;
- f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
- f1apMsg->choice.initiatingMessage->value.present = \
- InitiatingMessage__value_PR_UEContextSetupRequest;
- ueSetReq =
- &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
-
- elementCnt = 12;
- ueSetReq->protocolIEs.list.count = elementCnt;
- ueSetReq->protocolIEs.list.size = \
- elementCnt * sizeof(UEContextSetupRequestIEs_t *);
+ uint8_t elementCnt = 0;
+ uint8_t measCfgIdx = 0;
+ MeasTiming_t *measTiming;
+ SSB_MTC_t *smtc;
- /* Initialize the UESetup members */
- CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
+ CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
+ if(!measTimingCfg->measTiming)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for measTiming in fillMeasTimingCfg");
+ return RFAILED;
+ }
- if(ueSetReq->protocolIEs.list.array == NULLP)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation for UE Context SetupRequest failed");
- break;
- }
+ elementCnt = 1;
+ measTimingCfg->measTiming->list.count = elementCnt;
+ measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
+ CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
+ if(!measTimingCfg->measTiming->list.array)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
+ return RFAILED;
+ }
- for(idx1=0; idx1<elementCnt; idx1++)
+ for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
+ {
+ CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
+ if(!measTimingCfg->measTiming->list.array[measCfgIdx])
{
- CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
- if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
- {
- break;
- }
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
+ return RFAILED;
}
+ }
- idx = 0;
-
- /*GNB CU UE F1AP ID*/
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
- ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = cuUeF1apId;
-
- /*GNB DU UE F1AP ID*/
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
- ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = duUeF1apId;
+ measCfgIdx = 0;
+ measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
+ CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
+ if(!measTiming->frequencyAndTiming)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
+ return RFAILED;
+ }
- /*Special Cell ID*/
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_SpCell_ID;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_NRCGI;
- Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
- if(Nrcgiret != ROK)
- {
- break;
- }
+ measTiming->frequencyAndTiming->carrierFreq = 623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
+ measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
- /*Served Cell Index*/
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_ServCellIndex;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_ServCellIndex;
- ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
- CELL_INDEX;
+ smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
+ smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
+ smtc->periodicityAndOffset.choice.sf20 = 0;
+ smtc->duration = SSB_MTC__duration_sf1;
+ return ROK;
+}
- /*CellULConfigured*/
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_SpCellULConfigured;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_CellULConfigured;
- ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
- CellULConfigured_none;
+/*******************************************************************
+ *
+ * @brief Fill Measurement Timing Configuration Octet string
+ *
+ * @details
+ *
+ * Function : fillMeasConfigBuf
+ *
+ * Functionality: Fill Measurement Timing Configuration Octet string
+
+ *
+ * @params[in] MeasConfig_t *measConfgBuf
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
+{
+ uint8_t ret = RFAILED;
+ asn_enc_rval_t encRetVal;
+ MeasurementTimingConfigurationRrc_t measTimingConfig;
- /*CUtoDURRCContainer*/
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_CUtoDURRCInformation;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
- if(fillCuToDuContainer(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
+ while(true)
+ {
+ measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
+ CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
+ if(!measTimingConfig.criticalExtensions.choice.c1)
{
- break;
- }
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for measurement configuration extension");
+ return RFAILED;
+ }
+ measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
- /*Special Cells to be SetupList*/
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_SCell_ToBeSetup_List;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
- SplCellListret = BuildSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
- if(SplCellListret != ROK)
- {
- break;
- }
- /*SRBs To Be Setup List*/
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_SRBs_ToBeSetup_List;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
- SrbSetupret = BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
- if(SrbSetupret != ROK)
- {
- break;
- }
- /*DRBs to Be Setup List*/
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_DRBs_ToBeSetup_List;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
- ret1 = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
- if(ret1 != ROK)
- {
- break;
- }
- /* RRC Container for security mode */
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_RRCContainer;
- char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
- bufLen =9;
- ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = bufLen;
- CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
- ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
- if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
+ CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
+ if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
- break;
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for measurement timing configuration IE");
+ return RFAILED;
}
- memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, 0, bufLen);
- memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
- /* RRC delivery status request */
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_RRCDeliveryStatusRequest;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
- ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = \
- RRCDeliveryStatusRequest_true;
-
- /* Bit Rate hardcoded as in reference logs */
- idx++;
- ueSetReq->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
- ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
- ueSetReq->protocolIEs.list.array[idx]->value.present = \
- UEContextSetupRequestIEs__value_PR_BitRate;
- char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
- bufLen = 4;
- ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
- CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
- ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
- if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
+ ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
+ if(ret != ROK)
{
- DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
- break;
+ DU_LOG( "\nERROR --> F1AP : Failed to fill measurement timing configuration IE");
+ break;
}
- memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
- memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
-
- xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
- /* Encode the F1SetupRequest type as APER */
- memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ /* Encode measurement timing configuration into octet string */
+ xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
- encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
- encBuf);
+ encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
+
/* Encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG( "\nERROR --> F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- break;
+ DU_LOG( "\nERROR --> F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
- for(int i=0; i< encBufSize; i++)
- {
- DU_LOG("%x",encBuf[i]);
- }
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
}
- /* Sending msg */
- if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL) != ROK)
+ measTimingConfigBuf->size = encBufSize;
+ CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
+ if(!measTimingConfigBuf->buf)
{
- DU_LOG("\nERROR --> F1AP : Sending UE Context Setup Request Failed");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed fillMeasTimingConfigBuf");
+ break;
}
+ memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
ret = ROK;
break;
}
- FreeUeContextSetupReq(f1apMsg);
-
+ freeMeasuementTimingConfig(measTimingConfig);
return ret;
-}/* End of BuildAndSendUeContextSetupReq*/
+}
-/**********************************************************************
- * @brief Function to extractTeId received in UE context setup Response
+/******************************************************************
+ *
+ * @brief Free RRC reconfiguration non-critical extension
*
* @details
*
- * Function : extractTeId
- *
- * Functionality:
- * - Function to extract TeId
+ * Function : freeRrcReconfigNonCriticalExt
*
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
+ * Functionality: Free RRC reconfiguration non-critical extension
*
- **********************************************************************/
-uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
+ * @params[in] RRC reconfiguration IE
+ * @return void
+ *
+ * ****************************************************************/
+void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
{
- uint8_t arrIdx = 0;
- uint32_t teId = 0;
- GTPTunnel_t *gtpDl = NULLP;
-
- for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
+ if(rrcRecfg->masterCellGroup)
{
- if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
- {
- if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
- {
- gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
- if(gtpDl->gTP_TEID.size > 0)
- {
- teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
- }
- else
- DU_LOG("\nERROR --> EGTP: No TeId received");
- return(teId);
- }
- }
+ CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
}
- return teId;
}
-/****************************************************************
- * @brief Function to add Drb tunnels
+/******************************************************************
+ *
+ * @brief Free measurement object addmod list
*
* @details
*
- * Function : addDrbTunnels
- *
- * Functionality:
- * - Function to add Drb tunnels
+ * Function : freeMeasObjToAddModList
*
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
+ * Functionality: Free measurement object add mod list
+ *
+ * @params[in] Measurement object add/mod list
+ * @return void
*
* ****************************************************************/
-uint8_t addDrbTunnels(uint8_t teId)
+void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
{
- uint8_t ret = ROK;
- EgtpTnlEvt tnlEvt;
+ uint8_t objIdx;
+ MeasObjectNR_t *measObject;
- if(teId > MAX_TEID || teId < MIN_TEID)
- {
- DU_LOG("\nERROR --> EGTP : TEID(%x) OUT Of Range",teId);
- }
- memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
- tnlEvt.action = EGTP_TNL_MGMT_ADD;
- tnlEvt.lclTeid = teId;
- tnlEvt.remTeid = teId;
- ret = cuEgtpTnlMgmtReq(tnlEvt);
- if(ret != ROK)
+ if(measObjList->list.array)
{
- DU_LOG("\nERROR --> EGTP : Tunnel management request failed for teId %x", teId);
+ for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
+ {
+ if(measObjList->list.array[objIdx])
+ {
+ if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
+ {
+ measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
+ CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
+ CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
+ CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
+ if(measObject->absThreshSS_BlocksConsolidation)
+ {
+ CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
+ CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
+ CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
+ CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
+ }
+ CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
+ CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
+ CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
+ CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
+ CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
+ }
+ CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
+ }
+ }
+ CU_FREE(measObjList->list.array, measObjList->list.size);
}
- return ROK;
}
-/****************************************************************
- * @brief Function to process Drb Setup List
+/******************************************************************
+ *
+ * @brief Free report config add mod list
*
* @details
*
- * Function : procDrbSetupList
- *
- * Functionality:
- * - Function to process DRB Setup List
+ * Function : freeReportCfgToAddModList
*
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
+ * Functionality: Free report config add mod list
+ *
+ * @params[in] Report config list
+ * @return void
*
* ****************************************************************/
-uint8_t procDrbSetupList(DRBs_Setup_List_t *drbSetupList)
+void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
{
- uint8_t arrIdx = 0;
- uint32_t teId = 0;
- DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
+ uint8_t reportCfgIdx;
+ ReportConfigToAddMod_t *reportCfg;
+ ReportConfigNR_t *reportCfgNr;
+ EventTriggerConfig_t *eventTriggCfg;
- if(drbSetupList != NULLP)
+ if(reportCfgList->list.array)
{
- for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
+ for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
{
- drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
- if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
+ if(reportCfgList->list.array[reportCfgIdx])
{
- /* extracting teId */
- teId = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
- if(teId > 0)
+ reportCfg = reportCfgList->list.array[reportCfgIdx];
+ if(reportCfg->reportConfig.choice.reportConfigNR)
{
- if(addDrbTunnels(teId)== ROK)
- {
- DU_LOG("\nDEBUG --> EGTP: Tunnel Added for TeId %d", teId);
- }
+ reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
+ if(reportCfgNr->reportType.choice.eventTriggered)
+ {
+ eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
+ CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
+ CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
+ CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
+ CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
+ }
}
- else
- return RFAILED;
}
+ CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
}
+ CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
}
- return ROK;
}
-/****************************************************************
- * @brief Function to process Ue Context Setup Response
+/******************************************************************
+ *
+ * @brief Free measurement id to add mod list
*
* @details
*
- * Function : procUeContextSetupResponse
- *
- * Functionality:
- * - Function to process Ue Context Setup Response
+ * Function : freeMeasIdToAddModList
*
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
+ * Functionality: Free measurement id to add mod list
+ *
+ * @params[in] Measurement id to add mod list
+ * @return void
*
* ****************************************************************/
-uint8_t procUeContextSetupResponse(F1AP_PDU_t *f1apMsg)
+void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
{
- uint8_t idx, duUeF1apId;
- UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
- ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
-
- for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
+ uint8_t measIdIdx;
+ if(measIdList->list.array)
{
- switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
+ for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
{
- case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
- {
- duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
- break;
- }
- case ProtocolIE_ID_id_DRBs_Setup_List:
- {
- /* Adding Tunnels for successful DRB */
- procDrbSetupList(&ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
- break;
-
- }
+ CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
}
+ CU_FREE(measIdList->list.array, measIdList->list.size);
}
- ueCb[duUeF1apId-1].f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
- return ROK;
}
-/****************************************************************
- * @brief Function to process Ul Rrc Msg received from DU
+/*******************************************************************
+ *
+ * @brief Free quantity config
*
* @details
*
- * Function : procUlRrcMsg
+ * Function : freeQunatityConfig
*
- * Functionality:
- * - Function to process Ul Rrc Msg received from DU
+ * Functionality: Free quantity config
*
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
+ * @params[in] Quantity Config
+ * @return void
*
* ****************************************************************/
-
-uint8_t procUlRrcMsg(F1AP_PDU_t *f1apMsg)
+void freeQuantityConfig(QuantityConfig_t *quantityCfg)
{
- uint8_t idx, ret, srbId, rrcMsgType;
- uint8_t cuUeF1apId, duUeF1apId;
- uint8_t *rrcContainer = NULLP;
- uint16_t rrcContLen;
- ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
-
- ret = ROK;
- ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
+ uint8_t quanCfgIdx;
+ QuantityConfigNR_t *quantityCfgNr;
- for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
+ if(quantityCfg->quantityConfigNR_List)
{
- switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
+ if(quantityCfg->quantityConfigNR_List->list.array)
{
- case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
- {
- cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
- break;
- }
- case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
- {
- duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
- break;
- }
- case ProtocolIE_ID_id_SRBID:
- srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
- break;
- case ProtocolIE_ID_id_RRCContainer:
- {
- rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
- CU_ALLOC(rrcContainer, rrcContLen)
- if(!rrcContainer)
- {
- DU_LOG("\nERROR --> F1AP : Failed to allocated memory in procUlRrcMsg");
- return RFAILED;
- }
- memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
- rrcContLen);
- break;
- }
-
- default:
- DU_LOG("\nERROR --> F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
- break;
+ for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
+ {
+ if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
+ {
+ quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
+ CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
+ CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
+ CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
+ if(quantityCfgNr->quantityConfigRS_Index)
+ {
+ CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
+ CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
+ CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
+ CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
+ }
+ CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
+ }
+ }
+ CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
}
+ CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
}
- if(srbId == 1)
+}
+
+/******************************************************************
+ *
+ * @brief Free measurement Config
+ *
+ * @details
+ *
+ * Function : freeMeasConfig
+ *
+ * Functionality: Free measurement config
+ *
+ * @params[in] Measurement config
+ * @return void
+ *
+ * ****************************************************************/
+void freeMeasConfig(MeasConfigRrc_t *measConfig)
+{
+ if(measConfig->measObjectToAddModList)
{
- ueCb[duUeF1apId-1].f1apMsgDb.dlRrcMsgCount++;
- rrcMsgType = setDlRRCMsgType(duUeF1apId);
- if(rrcMsgType == REGISTRATION_ACCEPT)
- {
- DU_LOG("\nINFO --> F1AP: Sending DL RRC MSG for RRC Registration Accept");
- ret = BuildAndSendDLRRCMessageTransfer(duUeF1apId, srbId, rrcMsgType);
- }
- if(rrcMsgType == UE_CONTEXT_SETUP_REQ)
- {
- DU_LOG("\nINFO --> F1AP: Sending Ue Context Setup Req");
- ret = BuildAndSendUeContextSetupReq(cuUeF1apId, duUeF1apId,\
- rrcContLen, rrcContainer);
- }
- if(rrcMsgType == SECURITY_MODE_COMPLETE)
+ freeMeasObjToAddModList(measConfig->measObjectToAddModList);
+ CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
+ }
+ if(measConfig->reportConfigToAddModList)
+ {
+ freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
+ CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
+ }
+ if(measConfig->measIdToAddModList)
+ {
+ freeMeasIdToAddModList(measConfig->measIdToAddModList);
+ CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
+ }
+ if(measConfig->s_MeasureConfig)
+ {
+ CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
+ }
+ if(measConfig->quantityConfig)
+ {
+ freeQuantityConfig(measConfig->quantityConfig);
+ CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
+ }
+}
+/******************************************************************
+ *
+ * @brief Free DRB to AddMod List
+ *
+ * @details
+ *
+ * Function : freeDrbToAddModList
+ *
+ * Functionality: Free SRB to AddMod List
+ *
+ * @params[in] SBR to add/mod list
+ * @return void
+ *
+ * ****************************************************************/
+void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
+{
+ uint8_t drbIdx;
+ if(drbToAddList->list.array)
+ {
+ for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
{
- /* To trigger the DL RRC Msg for RRC Reconfig */
- ueCb[duUeF1apId-1].f1apMsgDb.dlRrcMsgCount++;
- rrcMsgType = setDlRRCMsgType(duUeF1apId);
- if(rrcMsgType == RRC_RECONFIG)
+ if(drbToAddList->list.array[drbIdx]->pdcp_Config)
{
- DU_LOG("\nINFO --> F1AP: Sending DL RRC MSG for RRC Reconfig");
- BuildAndSendDLRRCMessageTransfer(duUeF1apId, srbId, rrcMsgType);
+ if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
+ {
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
+ }
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
}
+ CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
}
- if(rrcMsgType == UE_CONTEXT_MOD_REQ)
- {
- DU_LOG("\nINFO --> F1AP: Sending UE Context Modification Request");
- BuildAndSendUeContextModificationReq(duUeF1apId);
- }
+ CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
}
- return ret;
}
-/****************************************************************
- * @brief Build And Send F1ResetAck
+/******************************************************************
+ *
+ * @brief Free SRB to AddMod List
*
* @details
*
- * Function : FreeF1ResetAck
+ * Function : freeSrbToAddModList
*
- * Functionality:
- * - Build And Send F1ResetRSP
+ * Functionality: Free SRB to AddMod List
*
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
+ * @params[in] SBR to add/mod list
+ * @return void
*
* ****************************************************************/
-void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
+void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
{
- uint8_t idx;
- ResetAcknowledge_t *f1ResetAck;
-
- if(f1apMsg)
+ uint8_t srbIdx;
+ if(srbToAddList->list.array)
{
- if(f1apMsg->choice.successfulOutcome)
+ for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
{
- f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
+ CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
+ if(srbToAddList->list.array[srbIdx]->pdcp_Config)
+ {
+ CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
+ CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
+ }
- if(f1ResetAck->protocolIEs.list.array)
- {
- for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
- {
- if(f1ResetAck->protocolIEs.list.array[idx])
- {
- CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
- }
- }
- CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
- }
- CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
+ CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
}
- CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
+ CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
}
}
-/****************************************************************
- * @brief Build And Send F1ResetAck
+/******************************************************************
+ *
+ * @brief Free Radio Bearer Config
*
* @details
*
- * Function : BuildAndSendF1ResetAck
+ * Function : freeRadioBearerConfig
*
- * Functionality:
- * - Build And Send F1ResetRSP
+ * Functionality: Free Radio Bearer config
*
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
+ * @params[in] Radio bearer config
+ * @return void
*
* ****************************************************************/
-
-uint8_t BuildAndSendF1ResetAck()
+void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
{
- uint8_t idx = 0;
- uint8_t elementCnt = 0;
- uint8_t ret = RFAILED;
- F1AP_PDU_t *f1apMsg = NULL;
- ResetAcknowledge_t *f1ResetAck = NULLP;
- asn_enc_rval_t encRetVal;
- DU_LOG("\nINFO --> F1AP : Building F1 Reset Acknowledgment \n");
+ if(radioBearerConfig->srb_ToAddModList)
+ {
+ freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
+ CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
+ }
+ if(radioBearerConfig->drb_ToAddModList)
+ {
+ freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
+ CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
+ }
+}
- do{
- /* Allocate the memory for F1ResetRequest_t */
- CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
- if(f1apMsg == NULLP)
+/******************************************************************
+ *
+ * @brief Free reconfiguration message
+ *
+ * @details
+ *
+ * Function : freeRrcReconfig
+ *
+ * Functionality: Free reconfiguration message
+ *
+ * @params[in] RRC Reconfiguration message
+ * @return void
+ *
+ * ****************************************************************/
+void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
+{
+ if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
+ {
+ if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
- break;
+ freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
+ CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
}
-
- f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
-
- CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
- if(f1apMsg->choice.successfulOutcome == NULLP)
+ if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
- break;
+ freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
+ CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
}
-
- f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
+ if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
+ {
+ freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
+ CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
+ }
+ CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Fill SRB To Add Mod list
+ *
+ * @details
+ *
+ * Function : fillSrbToAddModList
+ *
+ * Functionality: fill SRB to Add Mod list
+ *
+ * @params[in] UE control block
+ * SRB to Add/Mod list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
+{
+ uint8_t srbIdx, srbDbIdx, elementCnt = 0;
+
+ if(updateAllRbCfg)
+ elementCnt = ueCb->numSrb;
+ else
+ {
+ for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
+ {
+ if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
+ elementCnt++;
+ }
+ }
+
+ if(!elementCnt)
+ {
+ DU_LOG("INFO --> F1AP : No SRB available to add or modify");
+ return ROK;
+ }
+
+ srbToAddList->list.count = elementCnt;
+ srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
+
+ CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
+ if(!srbToAddList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
+ return RFAILED;
+ }
+
+ srbIdx = 0;
+ for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
+ {
+ if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
+ continue;
+
+ CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
+ if(!srbToAddList->list.array[srbIdx])
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
+ return RFAILED;
+ }
+
+ srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
+
+ /* Reestablish PDCP */
+ CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
+ if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
+ return RFAILED;
+ }
+ *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
+
+ /* PDCP configuration */
+ CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
+ if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
+ return RFAILED;
+ }
+
+ /* Reordering timer */
+ CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
+ if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
+ return RFAILED;
+ }
+ *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
+
+ srbIdx++;
+ }
+ return ROK;
+}
+
+/******************************************************************
+ *
+ * @biief Fill DRBeTo Add Mod list
+ *
+ * @details
+ *
+ * Function : fillDrbToAddModList
+ *
+ * Functionality: fill DRB to Add Mod list
+ *
+ * @params[in] UE control block
+ * DRB to Add/Mod list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
+{
+ uint8_t drbIdx, drbDbIdx, elementCnt = 0;
+
+ if(updateAllRbCfg)
+ elementCnt = ueCb->numDrb;
+ else
+ {
+ for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
+ {
+ if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
+ elementCnt++;
+ }
+ }
+
+ if(!elementCnt)
+ {
+ DU_LOG("INFO --> F1AP : No DRB available to add or modify");
+ return ROK;
+ }
+
+
+ drbToAddList->list.count = elementCnt;
+ drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
+
+ CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
+ if(!drbToAddList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
+ return RFAILED;
+ }
+
+ drbIdx = 0;
+ for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
+ {
+ if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
+ continue;
+
+ CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
+ if(!drbToAddList->list.array[drbIdx])
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
+ return RFAILED;
+ }
+
+ /* DRB Id */
+ drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
+
+ /* PDCP Config */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
+ return RFAILED;
+ }
+
+ /* PDCP Config -> DRB */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
+ return RFAILED;
+ }
+
+ /* DRB -> Discard Timer */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
+ return RFAILED;
+ }
+ *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
+
+ /* UL PDCP SN length */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
+ return RFAILED;
+ }
+ *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
+
+ /* DL PDCP SN length */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
+ return RFAILED;
+ }
+ *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
+
+ /* Header Compression */
+ drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
+ drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
+
+ /* Reordering timer */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
+ return RFAILED;
+ }
+ *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
+
+ drbIdx++;
+ }
+
+ return ROK;
+}
+
+/******************************************************************
+ *
+ * @brief Fill Radio bearer configuration
+ *
+ * @details
+ *
+ * Function : fillRadioBearerConfig
+ *
+ * Functionality: Fill Radio bearer configuration
+ *
+ * @params[in] UE control block
+ * Radio bearer config pointer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
+{
+ /* SRB To Add/Mod List */
+ CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
+ if(!radioBearerConfig->srb_ToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
+ return RFAILED;
+ }
+ if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: failed to fill SRB to AddMod List");
+ return RFAILED;
+ }
+
+ /* DRB To Add/Mod List */
+ CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
+ if(!radioBearerConfig->drb_ToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
+ return RFAILED;
+ }
+ if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: failed to fill DRB to AddMod List ");
+ return RFAILED;
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill measurement object to add/mod list
+ *
+ * @details
+ *
+ * Function : fillMeasObjToAddModList
+ *
+ * Functionality: Fill measurement object to add/mod list
+ *
+ * @params[in] Measurement object to add/mod list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
+{
+ uint8_t elementCnt, objIdx;
+ MeasObjectNR_t *measObject;
+
+ elementCnt = 1;
+ measObjList->list.count = elementCnt;
+ measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
+
+ CU_ALLOC(measObjList->list.array, measObjList->list.size);
+ if(!measObjList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for measurement object list's array");
+ return RFAILED;
+ }
+
+ for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
+ {
+ CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
+ if(!measObjList->list.array[objIdx])
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for measurement object list's array element");
+ return RFAILED;
+ }
+ }
+
+ objIdx = 0;
+ measObjList->list.array[objIdx]->measObjectId = 1;
+ measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
+ CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
+ if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for mesurement object NR");
+ return RFAILED;
+ }
+
+ measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
+
+ /* SSB frequency */
+ CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
+ if(!measObject->ssbFrequency)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
+
+ /* Subcarrier spacing */
+ CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
+ if(!measObject->ssbSubcarrierSpacing)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
+
+ /* SMTC1 */
+ CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
+ if(!measObject->smtc1)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ measObject->smtc1->duration = SSB_MTC__duration_sf1;
+ measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
+ measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
+
+ /* Absoulute threshold SSB consolidation */
+ CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
+ if(!measObject->absThreshSS_BlocksConsolidation)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+
+ /* RSRP threshold */
+ CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
+ if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
+
+ /* RSRQ threshold */
+ CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
+ if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
+
+ /* SINR threshold */
+ CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
+ if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
+
+ /* Number of SSBs to average */
+ CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
+ if(!measObject->nrofSS_BlocksToAverage)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->nrofSS_BlocksToAverage) = 2;
+
+ /* Quantity Config index */
+ measObject->quantityConfigIndex = 1;
+
+ /* Offset MO */
+ /* RSRP offset for SSB */
+ CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
+ if(!measObject->offsetMO.rsrpOffsetSSB)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
+
+ /* RSRQ offset for SSB */
+ CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
+ if(!measObject->offsetMO.rsrpOffsetSSB)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
+
+ /* SINR offset for SSB */
+ CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
+ if(!measObject->offsetMO.sinrOffsetSSB)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill Report configuration to Add/mod list
+ *
+ * @details
+ *
+ * Function : fillReportCfgToAddModList
+ *
+ * Functionality: Fill Report configuration to Add/mod list
+ *
+ * @params[in] Report Config To Add/Mod List
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
+{
+ uint8_t elementCnt;
+ uint8_t reportCfgIdx;
+ ReportConfigToAddMod_t *reportCfg;
+ ReportConfigNR_t *reportCfgNr;
+ EventTriggerConfig_t *eventTriggCfg;
+
+ elementCnt = 1;
+ reportCfgList->list.count = elementCnt;
+ reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
+
+ CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
+ if(!reportCfgList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
+ return RFAILED;
+ }
+
+ for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
+ {
+ CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
+ if(!reportCfgList->list.array[reportCfgIdx])
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
+ return RFAILED;
+ }
+ }
+
+ reportCfgIdx = 0;
+ reportCfg = reportCfgList->list.array[reportCfgIdx];
+ reportCfg->reportConfigId = 1;
+ reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
+
+ /* Report Configuration for NR */
+ CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
+ if(!reportCfg->reportConfig.choice.reportConfigNR)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
+ return RFAILED;
+ }
+ reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
+
+ /* Report Type */
+ reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
+ CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
+ if(!reportCfgNr->reportType.choice.eventTriggered)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
+ return RFAILED;
+ }
+ eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
+
+ /* Event 3 */
+ eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
+ CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
+ if(!eventTriggCfg->eventId.choice.eventA3)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
+ return RFAILED;
+ }
+
+ eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
+ eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
+ eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
+ eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
+ eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
+ eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
+
+ /* Reference Signal Type */
+ eventTriggCfg->rsType = NR_RS_Type_ssb;
+
+ /* Report Interval */
+ eventTriggCfg->reportInterval = ReportInterval_ms1024;
+
+ /* Report Amount */
+ eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
+
+ /* Report Quantity cell */
+ eventTriggCfg->reportQuantityCell.rsrp = true;
+ eventTriggCfg->reportQuantityCell.rsrq = false;
+ eventTriggCfg->reportQuantityCell.sinr = false;
+
+ /* Maximum reported cells */
+ eventTriggCfg->maxReportCells = 3;
+
+ /* Report qunatity RS Indexes */
+ CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
+ if(!eventTriggCfg->reportQuantityRS_Indexes)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
+ return RFAILED;
+ }
+ eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
+ eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
+ eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
+
+ /* Maximum number of RS indexes to report */
+ CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
+ if(!eventTriggCfg->maxNrofRS_IndexesToReport)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
+ return RFAILED;
+ }
+ *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
+
+ /* Include Beam measurement */
+ eventTriggCfg->includeBeamMeasurements = false;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill measurement Id to add/mod list
+
+ * @details
+ *
+ * Function : fillMeasIdToAddModList
+ *
+ * Functionality: Fill measurement Id to add/mod list
+ *
+ * @params[in] Measurement Id to add/mod list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
+{
+ uint8_t elementCnt;
+ uint8_t measIdIdx;
+
+ elementCnt = 1;
+ measIdList->list.count = elementCnt;
+ measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
+
+ CU_ALLOC(measIdList->list.array, measIdList->list.size);
+ if(!measIdList->list.array)
+ {
+ return RFAILED;
+ }
+
+ for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
+ {
+ CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
+ if(!measIdList->list.array[measIdIdx])
+ {
+ return RFAILED;
+ }
+
+ measIdIdx=0;
+ measIdList->list.array[measIdIdx]->measId = 1;
+ measIdList->list.array[measIdIdx]->measObjectId = 1;
+ measIdList->list.array[measIdIdx]->reportConfigId = 1;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill s-measurement configuration
+ *
+ * @details
+ *
+ * Function : fillSMeasConfig
+ *
+ * Functionality: Fill s-measurement configuration
+ *
+ * @params[in] s-Measurement config
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
+{
+ sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
+ sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill quantity config
+ *
+ * @details
+ *
+ * Function : fillQunatityConfig
+ *
+ * Functionality: Fill quantity config
+ *
+ * @params[in] Quantity Config
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
+{
+ uint8_t elementCnt = 0;
+ uint8_t quanCfgIdx = 0;
+ QuantityConfigNR_t *quantityCfgNr;
+
+ CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
+ if(!quantityCfg->quantityConfigNR_List)
+ {
+ return RFAILED;
+ }
+
+ elementCnt = 1;
+ quantityCfg->quantityConfigNR_List->list.count = elementCnt;
+ quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
+
+ CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
+ if(!quantityCfg->quantityConfigNR_List->list.array)
+ {
+ return RFAILED;
+ }
+
+ for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
+ {
+ CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
+ if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
+ {
+ return RFAILED;
+ }
+ }
+
+ quanCfgIdx = 0;
+ quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
+
+ /* Quantity Config of Reference signal */
+ CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
+
+ CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
+
+ CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
+
+ /* Quantity Config RS index */
+ CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
+ if(!quantityCfgNr->quantityConfigRS_Index)
+ {
+ return RFAILED;
+ }
+
+ CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
+
+ CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
+
+ CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill measurement configuration
+ *
+ * @details
+ *
+ * Function : fillMeasConfig
+ *
+ * Functionality: Fill measurement configuration
+ *
+ * @params[in] Measurement config
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
+{
+ /* Measurement object to add/mod list */
+ CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
+ if(!measConfig->measObjectToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
+ return RFAILED;
+ }
+ if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failure in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+
+ /* Report Config To add/mod list */
+ CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
+ if(!measConfig->reportConfigToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for report config list in fillMeasConfig");
+ return RFAILED;
+ }
+ if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failure in fillReportCfgToAddModList");
+ return RFAILED;
+ }
+
+ /* Measurement Id to add/mod list */
+ CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
+ if(!measConfig->measIdToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for measuerment id list in fillMeasConfig");
+ return RFAILED;
+ }
+ if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failure in fillMeasIdToAddModList");
+ return RFAILED;
+ }
+
+ /* S-Measurement config */
+ CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
+ if(!measConfig->s_MeasureConfig)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for s measuerment config in fillMeasConfig");
+ return RFAILED;
+ }
+ if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failure in fillSMeasConfig");
+ return RFAILED;
+ }
+
+ /* Qunatity Config */
+ CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
+ if(!measConfig->quantityConfig)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for quantity config in fillMeasConfig");
+ return RFAILED;
+ }
+ if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failure in fillQuantityConfig");
+ return RFAILED;
+ }
+
+return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill RRC reconfiguration non-critical extension IE
+ *
+ * @details
+ *
+ * Function : fillRrcReconfigNonCriticalExt
+ *
+ * Functionality: Fill RRC reconfiguration non-critical extension
+ *
+ * @params[in] RRC Reconfig Non-critical extension
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
+{
+ CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
+ if(!rrcRecfg->masterCellGroup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
+ return RFAILED;
+ }
+
+ rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
+ CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
+ if(!rrcRecfg->masterCellGroup->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
+ return RFAILED;
+ }
+ memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
+
+#if 0
+ /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
+ * received from DU */
+ if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
+ return RFAILED;
+ }
+#endif
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill RRC reconfiguration structure
+ *
+ * @details
+ *
+ * Function : fillRrcReconfig
+ *
+ * Functionality: Fill RRC reconfiguration
+
+ *
+ * @params[in] UE Cb
+ * RRC reconfiguration structure
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
+{
+ memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
+
+ rrcReconfig->rrc_TransactionIdentifier = 1;
+ rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
+
+ CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
+ if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
+ {
+ DU_LOG("\nERROR --> F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
+ return RFAILED;
+ }
+
+ /* Radio Bearer Configuration */
+ CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
+ if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
+ return RFAILED;
+ }
+ if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to fill radio bearer config in fillRrcReconfig");
+ return RFAILED;
+ }
+
+ /* Measurement Configuration */
+ CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
+ if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
+ return RFAILED;
+ }
+ if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to fill measurement config in fillRrcReconfig");
+ return RFAILED;
+ }
+
+ /* Non Critical extension */
+ CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
+ if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
+ {
+ DU_LOG("\nERROR --> F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
+ return RFAILED;
+ }
+ if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to fill non critical extension in fillRrcReconfig");
+ return RFAILED;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill RRC reconfiguration Octet string
+ *
+ * @details
+ *
+ * Function : fillRrcReconfigBuf
+ *
+ * Functionality: Fill RRC reconfiguration octet string
+
+ *
+ * @params[in] OCTET_STRING_t buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t *rrcReconfigBuf, bool updateAllRbCfg)
+{
+ uint8_t ret = RFAILED;
+ asn_enc_rval_t encRetVal;
+ RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
+ rrcReconfig = &rrcRecfg;
+
+ while(true)
+ {
+ if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
+ break;
+ }
+
+ /* Encode RRC Reconfiguration */
+ xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
+
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ rrcReconfigBuf->size = encBufSize;
+ CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
+ if(!rrcReconfigBuf->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillRrcReconfigBuf");
+ break;
+ }
+ memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
+ ret = ROK;
+ break;
+ }
+
+ freeRrcReconfig(rrcReconfig);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill HO preparation information Octet string
+ *
+ * @details
+ *
+ * Function : fillHOPreparationInfoBuf
+ *
+ * Functionality: Fill HO preparation information Octet string
+
+ *
+ * @params[in] HandoverPreparationInformation_t buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
+{
+ uint8_t ret = RFAILED;
+ asn_enc_rval_t encRetVal;
+ HandoverPreparationInformationRrc_t hoPrepInfo;
+ HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
+
+ while(true)
+ {
+
+ hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
+ CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
+ if(!hoPrepInfo.criticalExtensions.choice.c1)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
+ break;
+ }
+ hoPrepInfo.criticalExtensions.choice.c1->present = \
+ HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
+
+ CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
+ sizeof(HandoverPreparationInformationRrc_IEs_t));
+ if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
+ break;
+ }
+ hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
+
+ /* Fill UE Capability RAT container list */
+ ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
+ if(ret != ROK)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to fill UE Capability RAT container list");
+ break;
+ }
+
+ /* Fill Source config */
+ hoPrepInfoIe->sourceConfig = NULLP;
+ CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
+ if(!hoPrepInfoIe->sourceConfig)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
+ return RFAILED;
+ }
+ ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
+
+ if(ret != ROK)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to fill Rrc reconfiguration buffer");
+ return RFAILED;
+ }
+
+ hoPrepInfoIe->rrm_Config = NULLP;
+ hoPrepInfoIe->as_Context = NULLP;
+ hoPrepInfoIe->nonCriticalExtension = NULLP;
+
+ /* encode UE Capability RAT Container List into duToCuRrcContainer */
+ xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
+ &hoPrepInfo, PrepFinalEncBuf, encBuf);
+
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ hoPrepInfoBuf->size = encBufSize;
+ CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
+ if(!hoPrepInfoBuf->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
+ break;
+ }
+ memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
+ ret = ROK;
+ break;
+ }
+ freeHOPreparationInfo(&hoPrepInfo);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills CuToDuContainer
+ *
+ * @details
+ *
+ * Function : fillCuToDuContainer
+ *
+ * Functionality: Fills CuToDuContainer
+ *
+ * @params[in] pointer to CUtoDURRCInformation_t
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
+{
+ uint8_t elementCnt = 0;
+ uint8_t ret = ROK;
+ uint8_t idx;
+
+ /* UE Capabulity RAT Container List */
+ CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
+ if(!rrcMsg->uE_CapabilityRAT_ContainerList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for UE capability RAT container list failed");
+ return RFAILED;
+ }
+ ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
+
+ CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
+ if(!rrcMsg->measConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for measurement configuration failed");
+ return RFAILED;
+ }
+ ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
+
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ {
+ /* IE extensions */
+ CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
+ if(rrcMsg->iE_Extensions)
+ {
+ elementCnt = 1;
+ rrcMsg->iE_Extensions->list.count = elementCnt;
+ rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
+
+ /* Initialize the CUtoDURRCInformation_ExtIEs */
+ CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
+
+ if(rrcMsg->iE_Extensions->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
+ ret = RFAILED;
+ }
+
+ for(idx=0; idx<elementCnt; idx++)
+ {
+ CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
+ if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for array elements failed");
+ ret = RFAILED;
+ }
+ }
+
+ idx = 0;
+#if 0
+ /* Cell Group Configuration */
+ rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
+ rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
+ rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present =\
+ CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
+ ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
+ idx++;
+#endif
+ /* Handover Preparation Information */
+ rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
+ rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
+ rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present = \
+ CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
+ ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
+ }
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Free CuToDuContainer
+ *
+ * @details
+ *
+ * Function : FreeCuToDuInfo
+ *
+ * Functionality: Free CuToDuContainer
+ *
+ * @params[in] pointer to CUtoDURRCInformation_t
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
+{
+ uint8_t idx, idx2;
+
+ if(rrcMsg->uE_CapabilityRAT_ContainerList)
+ {
+ if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
+ CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
+ CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
+ }
+ if(rrcMsg->iE_Extensions)
+ {
+ if(rrcMsg->iE_Extensions->list.array)
+ {
+ for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
+ {
+ if(rrcMsg->iE_Extensions->list.array[idx])
+ {
+ switch(rrcMsg->iE_Extensions->list.array[idx]->id)
+ {
+ case ProtocolIE_ID_id_CellGroupConfig:
+ if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
+ {
+ CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
+ rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
+
+ }
+ break;
+ default:
+ DU_LOG("\nERROR --> F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
+ rrcMsg->iE_Extensions->list.array[idx]->id);
+ break;
+ }
+ }
+ break;
+ }
+ for(idx2 = 0; idx2 < idx; idx2++)
+ {
+ CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
+ }
+ CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
+
+ }
+
+ CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
+ }
+}
+/*******************************************************************
+ *
+ * @brief Builds and sends the UE Setup Request
+ *
+ * @details
+ *
+ * Function : BuildAndSendUeContextSetupReq
+ *
+ * Functionality: Constructs the UE Setup Request and sends
+ * it to the CU through SCTP.
+ *
+ * @params[in]
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb)
+{
+ uint8_t Nrcgiret, SplCellListret, SrbSetupret;
+ uint8_t ret= RFAILED, ret1;
+ uint8_t elementCnt;
+ uint8_t idx, idx1, bufLen, duIdx;
+ uint32_t spCellId;
+ DuDb *targetDuDb = NULLP;
+ F1AP_PDU_t *f1apMsg = NULLP;
+ UEContextSetupRequest_t *ueSetReq = NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+ memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
+
+ while(true)
+ {
+ DU_LOG("\nINFO --> F1AP : Building UE Context Setup Request\n");
+
+ CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
+ if(f1apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ break;
+ }
+
+ f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
+ CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
+ if(f1apMsg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ break;
+ }
+
+ f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
+ f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
+ f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
+
+ ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
+
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ elementCnt = 7;
+ else
+ elementCnt = 11;
+ ueSetReq->protocolIEs.list.count = elementCnt;
+ ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
+
+ /* Initialize the UESetup members */
+ CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
+
+ if(ueSetReq->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for UE Context SetupRequest failed");
+ break;
+ }
+
+ for(idx1=0; idx1<elementCnt; idx1++)
+ {
+ CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
+ if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
+ {
+ break;
+ }
+ }
+
+ idx = 0;
+
+ /*GNB CU UE F1AP ID*/
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
+ ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
+
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ {
+ /*GNB DU UE F1AP ID*/
+ idx++;
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
+ ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
+ }
+
+ /*Special Cell ID*/
+ idx++;
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ {
+ /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
+ SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
+ /* Since we are supporting only one cell per DU, accessing 0th index to
+ * get target cell info */
+ spCellId = targetDuDb->cellCb[0].nrCellId;
+ }
+ else
+ spCellId = ueCb->cellCb->nrCellId;
+ Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
+ if(Nrcgiret != ROK)
+ {
+ break;
+ }
+
+ /*Served Cell Index*/
+ idx++;
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
+ ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
+
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ {
+ /*CellULConfigured*/
+ idx++;
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCellULConfigured;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
+ ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
+ }
+
+ /*CUtoDURRCContainer*/
+ idx++;
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
+ if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
+ {
+ break;
+ }
+
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ {
+ /*Special Cells to be SetupList*/
+ idx++;
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_List;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
+ SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
+ if(SplCellListret != ROK)
+ {
+ break;
+ }
+ }
+
+ /*SRBs To Be Setup List*/
+ idx++;
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
+ SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
+ if(SrbSetupret != ROK)
+ {
+ break;
+ }
+
+ /*DRBs to Be Setup List*/
+ idx++;
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
+ ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
+ if(ret1 != ROK)
+ {
+ break;
+ }
+
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ {
+ /* RRC delivery status request */
+ idx++;
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
+ ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
+ }
+
+ /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
+ idx++;
+ ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
+ ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
+ ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
+
+ char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
+ bufLen = 4;
+ ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
+ CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
+ ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
+ if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
+ break;
+ }
+ memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
+ memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
+
+ 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 UE Context Setup Request structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ /* Sending msg */
+ if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Sending UE Context Setup Request Failed");
+ break;
+ }
+ ret = ROK;
+ break;
+ }
+ FreeUeContextSetupReq(f1apMsg);
+
+ return ret;
+}/* End of BuildAndSendUeContextSetupReq*/
+
+/**********************************************************************
+ * @brief Function to extractTeId received in UE context setup Response
+ *
+ * @details
+ *
+ * Function : extractTeId
+ *
+ * Functionality:
+ * - Function to extract TeId
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ **********************************************************************/
+uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
+{
+ uint8_t arrIdx = 0;
+ uint32_t teId = 0;
+ GTPTunnel_t *gtpDl = NULLP;
+
+ for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
+ {
+ if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
+ {
+ if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
+ {
+ gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
+ if(gtpDl->gTP_TEID.size > 0)
+ {
+ teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
+ }
+ else
+ DU_LOG("\nERROR --> EGTP: No TeId received");
+ return(teId);
+ }
+ }
+ }
+ return teId;
+}
+
+/****************************************************************
+ * @brief Function to add Drb tunnels
+ *
+ * @details
+ *
+ * Function : addDrbTunnels
+ *
+ * Functionality:
+ * - Function to add Drb tunnels
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
+{
+ uint8_t ret = ROK;
+ EgtpTnlEvt tnlEvt;
+
+ if(teId > MAX_TEID || teId < MIN_TEID)
+ {
+ DU_LOG("\nERROR --> EGTP : TEID(%x) OUT Of Range",teId);
+ }
+ memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
+ tnlEvt.action = EGTP_TNL_MGMT_ADD;
+ tnlEvt.lclTeid = teId;
+ tnlEvt.remTeid = teId;
+ ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : Tunnel management request failed for teId %x", teId);
+ }
+ return ROK;
+}
+
+/****************************************************************
+ * @brief Function to process Drb Setup List
+ *
+ * @details
+ *
+ * Function : procDrbSetupList
+ *
+ * Functionality:
+ * - Function to process DRB Setup List
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t procDrbSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_Setup_List_t *drbSetupList)
+{
+ uint8_t arrIdx = 0, drbIdx = 0;
+ uint32_t teId = 0;
+ DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
+
+ if(drbSetupList != NULLP)
+ {
+ for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
+ {
+ drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
+ if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
+ {
+ /* extracting teId */
+ teId = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
+ if(teId > 0)
+ {
+ if(addDrbTunnels(duId, teId)== ROK)
+ {
+ DU_LOG("\nDEBUG --> EGTP: Tunnel Added for TeId %d", teId);
+ }
+ /* As per Spec 38.473, in UE COntext Response, Tunnel information
+ * are sent to CU for setting up of Tunnels in DL direction.
+ * Search for DRB ID in CU databse */
+ for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
+ {
+ if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_Setup_Item.dRBID)
+ {
+ fillTeIdString(3, teId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
+ break;
+ }
+ }
+ }
+ else
+ return RFAILED;
+ }
+ }
+ }
+ return ROK;
+}
+
+/****************************************************************
+ * @brief Function to process Ue Context Setup Response
+ *
+ * @details
+ *
+ * Function : procUeContextSetupResponse
+ *
+ * Functionality:
+ * - Function to process Ue Context Setup Response
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
+{
+ uint8_t duIdx = 0, idx = 0, ueIdx = 0, rrcMsgType=0;
+ uint8_t duUeF1apId = 0, cuUeF1apId = 0;
+ DuDb *duDb = NULLP;
+ CuUeCb *ueCb = NULLP;
+ UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
+ OCTET_STRING_t *duToCuRrcContainer;
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
+
+ for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
+ {
+ switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
+ {
+ case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
+ {
+ cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
+ break;
+ }
+ case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
+ {
+ duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
+ ueCb = &duDb->ueCb[duUeF1apId-1];
+ /* If ue context is not present in du db, then create UE context
+ * here. This flow is hit in case of UE handover where UE
+ * context is created before UE performs RACH on target DU */
+ if(ueCb->gnbDuUeF1apId == 0)
+ {
+ /* Creating UE context in target DU */
+ memset(ueCb, 0, sizeof(CuUeCb));
+ ueCb->cellCb = &duDb->cellCb[0];
+ ueCb->gnbDuUeF1apId = duUeF1apId;
+ ueCb->gnbCuUeF1apId = cuUeF1apId;
+ ueCb->state = UE_HANDOVER_IN_PROGRESS;
+ ueCb->hoInfo.targetDuId = duId;
+ (duDb->numUe)++;
+
+ ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
+ ueCb->cellCb->numUe++;
+ }
+ break;
+ }
+ case ProtocolIE_ID_id_C_RNTI:
+ {
+ ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
+ break;
+ }
+ case ProtocolIE_ID_id_DRBs_Setup_List:
+ {
+ /* Adding Tunnels for successful DRB */
+ procDrbSetupList(duId, ueCb, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
+ break;
+ }
+ case ProtocolIE_ID_id_DUtoCURRCInformation:
+ {
+ DU_LOG("\nINFO --> Received Du to Cu RRC Information ");
+ duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
+ DUtoCURRCInformation.cellGroupConfig;
+ if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
+ DUtoCURRCInformation.cellGroupConfig)) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failed to extract Du to Cu RRC Information ");
+ return RFAILED;
+ }
+ break;
+ }
+ }
+ }
+
+ /* If the UE is in handover, UE context modification request is to be sent to
+ * source DU once UE context setup response is received from target DU */
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ {
+ DuDb *srcDuDb = NULLP;
+ CuUeCb *ueCbInSrcDu = NULLP;
+
+ /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
+ * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
+ for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
+ {
+ /* UE context setup response is received from target DU. Search all
+ * DUs to find source DU except this target DU Id.*/
+ if(cuCb.duInfo[duIdx].duId != duId)
+ {
+ for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
+ {
+ /* Check following:
+ * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
+ * received in UE context setup response since CU UE F1AP ID does not
+ * change for UE in handover.
+ * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
+ */
+ if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
+ (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
+ {
+ srcDuDb = &cuCb.duInfo[duIdx];
+ ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
+
+ /* Store source DU info in the new UE context created in
+ * tareget DU */
+ ueCb->hoInfo.sourceDuId = srcDuDb->duId;
+
+ /* Copy the received container to UeCb */
+ memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
+
+ if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
+ {
+ DU_LOG("\nERROR -> F1AP : Failed at BuildAndSendUeContextModificationReq()");
+ return RFAILED;
+ }
+ break;
+ }
+ }
+ }
+ if(srcDuDb && ueCbInSrcDu)
+ break;
+ }
+ }
+ else
+ {
+ ueCb->f1apMsgDb.dlRrcMsgCount++;
+ rrcMsgType = setDlRRCMsgType(ueCb);
+
+ DU_LOG("\nINFO --> F1AP: Sending DL RRC MSG for RRC reconfiguration");
+ if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
+ {
+ DU_LOG("\nINFO --> F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
+ return RFAILED;
+ }
+ }
+
+ return ROK;
+}
+
+/****************************************************************
+ * @brief Function to process Ul Rrc Msg received from DU
+ *
+ * @details
+ *
+ * Function : procUlRrcMsg
+ *
+ * Functionality:
+ * - Function to process Ul Rrc Msg received from DU
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
+{
+ uint8_t idx = 0, ret = ROK, srbId = 0, rrcMsgType = 0, duIdx=0;
+ uint8_t *rrcContainer = NULLP;
+ uint16_t rrcContLen = 0;
+ uint32_t cuUeF1apId = 0, duUeF1apId = 0;
+ DuDb *duDb = NULLP;
+ CuUeCb *ueCb = NULLP;
+ ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
+
+ ret = ROK;
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
+
+ for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
+ {
+ switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
+ {
+ case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
+ {
+ cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
+ break;
+ }
+ case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
+ {
+ duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
+ break;
+ }
+ case ProtocolIE_ID_id_SRBID:
+ srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
+ break;
+
+ case ProtocolIE_ID_id_RRCContainer:
+ {
+ rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
+ CU_ALLOC(rrcContainer, rrcContLen);
+ if(!rrcContainer)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocated memory in procUlRrcMsg");
+ return RFAILED;
+ }
+ memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
+
+ if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
+ {
+ uint8_t ueIdx = 0;
+ uint8_t srcDuId = duDb->ueCb[duUeF1apId-1].hoInfo.sourceDuId;
+ DuDb *srcDuDb = NULLP;
+
+ /* In target DU DB, mark UE as active and delete HO info */
+ duDb->ueCb[duUeF1apId-1].state = UE_ACTIVE;
+ memset(&duDb->ueCb[duUeF1apId-1].hoInfo, 0, sizeof(HandoverInfo));
+
+ /* Release UE context in source DU because the UE is now
+ * attached to target DU */
+ SEARCH_DU_DB(duIdx, srcDuId, srcDuDb);
+ for(ueIdx = 0; ueIdx < srcDuDb->numUe; ueIdx++)
+ {
+ if(srcDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
+ {
+ ret = BuildAndSendUeContextReleaseCommand(srcDuId, srcDuDb->ueCb[ueIdx].gnbCuUeF1apId, srcDuDb->ueCb[ueIdx].gnbDuUeF1apId);
+ if(ret != ROK)
+ {
+ DU_LOG("\nINFO --> F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
+ }
+ break;
+ }
+ }
+ return ret;
+ }
+ break;
+ }
+
+ default:
+ DU_LOG("\nERROR --> F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
+ break;
+ }
+ }
+
+ if(srbId == 1)
+ {
+ ueCb = &duDb->ueCb[duUeF1apId-1];
+ ueCb->f1apMsgDb.dlRrcMsgCount++;
+ rrcMsgType = setDlRRCMsgType(ueCb);
+ if(rrcMsgType == RRC_SETUP_COMPLETE)
+ {
+ DU_LOG("\nINFO --> F1AP: Sending DL RRC MSG for Security Mode Command");
+ ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
+ }
+ else if(rrcMsgType == SECURITY_MODE_COMPLETE)
+ {
+ DU_LOG("\nINFO --> F1AP: Sending DL RRC MSG for RRC Registration Accept");
+ BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
+ }
+ else if(rrcMsgType == REGISTRATION_COMPLETE)
+ {
+ DU_LOG("\nINFO --> F1AP: Sending Ue Context Setup Request");
+ ret = BuildAndSendUeContextSetupReq(duId, ueCb);
+ }
+ else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
+ {
+ DU_LOG("\nINFO --> F1AP: Sending UE Context Modification Request");
+ BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
+ }
+ }
+ return ret;
+}
+
+/****************************************************************
+ * @brief Build And Send F1ResetAck
+ *
+ * @details
+ *
+ * Function : FreeF1ResetAck
+ *
+ * Functionality:
+ * - Build And Send F1ResetRSP
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
+{
+ uint8_t idx;
+ ResetAcknowledge_t *f1ResetAck;
+
+ if(f1apMsg)
+ {
+ if(f1apMsg->choice.successfulOutcome)
+ {
+ f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
+
+ if(f1ResetAck->protocolIEs.list.array)
+ {
+ for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
+ {
+ if(f1ResetAck->protocolIEs.list.array[idx])
+ {
+ CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
+ }
+ }
+ CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
+ }
+ CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
+ }
+ CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
+ }
+}
+
+/****************************************************************
+ * @brief Build And Send F1ResetAck
+ *
+ * @details
+ *
+ * Function : BuildAndSendF1ResetAck
+ *
+ * Functionality:
+ * - Build And Send F1ResetRSP
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t BuildAndSendF1ResetAck()
+{
+ uint8_t idx = 0;
+ uint8_t elementCnt = 0;
+ uint8_t ret = RFAILED;
+ F1AP_PDU_t *f1apMsg = NULL;
+ ResetAcknowledge_t *f1ResetAck = NULLP;
+ asn_enc_rval_t encRetVal;
+ DU_LOG("\nINFO --> F1AP : Building F1 Reset Acknowledgment \n");
+
+ do{
+ /* Allocate the memory for F1ResetRequest_t */
+ CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
+ if(f1apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ break;
+ }
+
+ f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
+
+ CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
+ if(f1apMsg->choice.successfulOutcome == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed");
+ break;
+ }
+
+ f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
if(f1ResetAck->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1ResetAckIEs failed");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1ResetAckIEs failed");
+ break;
}
for(idx=0; idx<elementCnt; idx++)
{
- CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
- if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
- {
- break;
- }
+ CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
+ if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
+ {
+ break;
+ }
}
/*TransactionID*/
idx = 0;
/* Check encode results */
if(encRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode F1ResetAck structure (at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- break;
+ DU_LOG("\nERROR --> F1AP : Could not encode F1ResetAck structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for F1ResetAck \n");
- for(int i=0; i< encBufSize; i++)
- {
- DU_LOG("%x",encBuf[i]);
- }
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for F1ResetAck \n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
}
+
/* Sending msg */
- if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
+ /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
+ if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending F1 Reset Response failed");
- break;
+ DU_LOG("\nERROR --> F1AP : Sending F1 Reset Response failed");
+ break;
}
ret = ROK;
FreeF1ResetAck(f1apMsg);
return ret;
}
+
void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
{
uint8_t arrIdx =0;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t deleteEgtpTunnel(uint8_t *buf)
+uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
{
uint32_t teId = 0;
EgtpTnlEvt tnlEvt;
tnlEvt.action = EGTP_TNL_MGMT_DEL;
tnlEvt.lclTeid = teId;
tnlEvt.remTeid = teId;
- if((cuEgtpTnlMgmtReq(tnlEvt)) != ROK)
+ if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
{
DU_LOG("\nERROR --> EGTP : Failed to delete tunnel Id %d", teId);
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildUlTnlInfoforSetupMod(uint8_t ueId, uint8_t drbId, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
+uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
{
uint8_t arrIdx;
uint8_t ulCnt;
transportLayerAddress.buf[3] = 82;
ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
transportLayerAddress.bits_unused = 0;
+
+ ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
+ ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
+ ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
+ ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
/*GTP TEID*/
ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
else
{
ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
- gTP_TEID.buf[3] = cuCfgParams.egtpParams.currTunnelId++;
+ gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
}
+
+ ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
+ ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
+ ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
+ ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
return ROK;
}/*End of BuildULTnlInfo*/
*
* ****************************************************************/
-uint8_t FillDrbItemToSetupMod(uint8_t ueId, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
+uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
{
uint8_t ret = ROK;
/*Drb Id */
drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
+ ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
/*qoSInformation*/
drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
- ret = BuildQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
- ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2);
+ ret = BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
+ ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : BuildQOSInfo failed");
}
/*SNSSAI*/
- ret = BuildSNSSAI(&drbItem->qoSInformation.choice.\
- choice_extension->value.choice.DRB_Information.sNSSAI, cuCfgParams.snssaiList[1]);
+ ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
+ choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : BuildSNSSAI failed");
}
/*Flows mapped to DRB List*/
- ret = BuildFlowsMap(&drbItem->qoSInformation.choice.\
+ ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
- ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
+ ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : BuildFlowsMap failed");
}
/*ULUPTNLInformation To Be Setup List*/
- ret = BuildUlTnlInfoforSetupMod(ueId, drbItem->dRBID, &drbItem->uLUPTNLInformation_ToBeSetup_List, \
- ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
+ ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
+ &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : BuildUlTnlInfoforSetupMod failed");
/*RLCMode*/
drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
+ ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
+
+ ueCb->numDrb++;
return ROK;
}
*
* ****************************************************************/
-uint8_t FillDrbItemList(uint8_t ueId, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
+uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
{
drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
drbItemIe->criticality = Criticality_reject;
drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
- if(FillDrbItemToSetupMod(ueId, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
+ if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbItemToSetupMod failed");
return RFAILED;
*
* ****************************************************************/
-uint8_t BuildDrbToBeSetupList(uint8_t ueId, DRBs_ToBeSetupMod_List_t *drbSet)
+uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
{
uint8_t ret = ROK;
uint8_t arrIdx =0;
return RFAILED;
}
- ret = FillDrbItemList(ueId, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
+ ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbItemList failed");
*
* ****************************************************************/
-uint8_t FillDrbToBeModItem(uint8_t ueId, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
+uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
{
uint8_t ret = ROK;
+ uint drbIdx=0;
+ DrbInfo *drbToBeMod;
/*Drb Id */
drbItem->dRBID = DRB2 + arrIdx;
+ /* Search for DRB ID in CU databse */
+ for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
+ {
+ if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
+ {
+ drbToBeMod = &ueCb->drbList[drbIdx];
+ break;
+ }
+ }
+
/*qoSInformation*/
drbItem->qoSInformation = NULLP;
CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
- ret = BuildQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
- ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID);
+ ret = BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
+ ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : BuildQOSInfo failed");
}
/*SNSSAI*/
- ret = BuildSNSSAI(&drbItem->qoSInformation->choice.\
- choice_extension->value.choice.DRB_Information.sNSSAI,cuCfgParams.snssaiList[0]);
+ ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
+ choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : BuildSNSSAI failed");
}
/*Flows mapped to DRB List*/
- ret = BuildFlowsMap(&drbItem->qoSInformation->choice.\
+ ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
- ProtocolIE_ID_id_DRBs_ToBeModified_Item);
+ ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : BuildFlowsMap failed");
}/* End of QoS */
/*ULUPTNLInformation To Be Setup List*/
- ret = BuildUlTnlInfoforSetupMod(ueId, drbItem->dRBID, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
+ ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
ProtocolIE_ID_id_DRBs_ToBeModified_Item);
if(ret != ROK)
{
*
* ****************************************************************/
-uint8_t FillDrbToBeModItemList(uint8_t ueId, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
+uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
{
drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
drbItemIe->criticality = Criticality_reject;
drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
- if(FillDrbToBeModItem(ueId, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
+ if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbToBeModItem failed");
return RFAILED;
*
* ****************************************************************/
-uint8_t BuildDrbToBeModifiedList(uint8_t ueId, DRBs_ToBeModified_List_t *drbSet)
+uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
{
uint8_t ret = ROK;
uint8_t arrIdx =0;
return RFAILED;
}
- ret = FillDrbToBeModItemList(ueId, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
+ ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbToBeModItemList failed");
void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
{
uint8_t arrIdx =0 , ieId=0;
- UEContextModificationRequest_t *UeContextModifyReq = NULLP;
+ UEContextModificationRequest_t *ueContextModifyReq = NULLP;
if(f1apMsg)
{
if(f1apMsg->choice.initiatingMessage)
{
- UeContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
- if(UeContextModifyReq->protocolIEs.list.array)
+ ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
+ if(ueContextModifyReq->protocolIEs.list.array)
{
- for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
+ for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
{
- if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
+ if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
{
- ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
+ ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
switch(ieId)
{
case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
break;
case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
{
- FreeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
+ FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
choice.DRBs_ToBeSetupMod_List);
break;
}
case ProtocolIE_ID_id_DRBs_ToBeModified_List:
{
- FreeDrbToBeModifiedList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
- choice.DRBs_ToBeSetupMod_List);
+ FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
+ choice.DRBs_ToBeModified_List);
break;
}
+ case ProtocolIE_ID_id_TransmissionActionIndicator:
+ break;
+ case ProtocolIE_ID_id_RRCContainer:
+ {
+ CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
+ ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
+ }
}
- CU_FREE(UeContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
+ CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
}
}
- CU_FREE(UeContextModifyReq->protocolIEs.list.array, UeContextModifyReq->protocolIEs.list.size);
+ CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
}
CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
}
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
}
}
+
/*******************************************************************
*
* @brief Builds the Ue Context Modification Req
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendUeContextModificationReq(uint8_t ueId)
+uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
{
uint8_t ieIdx = 0;
uint8_t elementCnt = 0;
uint8_t ret = RFAILED;
+ CuUeCb *ueCb = (CuUeCb *)cuUeCb;
F1AP_PDU_t *f1apMsg = NULLP;
UEContextModificationRequest_t *ueContextModifyReq = NULLP;
-
asn_enc_rval_t encRetVal;
DU_LOG("\nINFO --> F1AP : Building Ue context modification request\n");
-
while(1)
{
CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
+ break;
}
f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
+ break;
}
f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
- elementCnt = 4;
+ if(action == MODIFY_UE)
+ elementCnt = 4;
+ else if(action == QUERY_CONFIG)
+ elementCnt = 3;
+ else if(action == RRC_RECONFIG_COMPLETE_IND)
+ elementCnt = 3;
+ else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
+ elementCnt = 5;
+
ueContextModifyReq->protocolIEs.list.count = elementCnt;
ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
if(ueContextModifyReq->protocolIEs.list.array == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
- break;
+ DU_LOG("\nERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
+ break;
}
for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
{
- CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
- if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
- break;
- }
+ CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
+ if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for UE context modifcation Request failed");
+ break;
+ }
}
-
ieIdx=0;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
- ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueId;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
ieIdx++;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
- ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueId;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
+
+ if(action == MODIFY_UE)
+ {
+ /* DRB to be setup list */
+ ieIdx++;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
+ UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
+ ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
+ value.choice.DRBs_ToBeSetupMod_List));
+
+ /* DRB to be modified list */
+ ieIdx++;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
+ UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
+ ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
+ value.choice.DRBs_ToBeModified_List));
+
+ /* TODO: DRB to be release list */
+
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
+ break;
+ }
- /* DRB to be setup list */
- ieIdx++;
- ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
- ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
- ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
- UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
- ret = BuildDrbToBeSetupList(ueId, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
- value.choice.DRBs_ToBeSetupMod_List));
+ /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE */
+ }
+ else if(action == QUERY_CONFIG)
+ {
+ ieIdx++;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
+ UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
+ }
+ else if(action == RRC_RECONFIG_COMPLETE_IND)
+ {
+ ieIdx++;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
+ UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
+ RRCReconfigurationCompleteIndicator_true;
+ }
+ else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
+ {
+ ieIdx++;
+ if(action == STOP_DATA_TX)
+ {
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
+ UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
+ TransmissionActionIndicator_stop;
+ }
+ else if (action == RESTART_DATA_TX)
+ {
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
+ UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
+ TransmissionActionIndicator_restart;
+ }
- /* DRB to be modified list */
- ieIdx++;
- ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
- ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
- ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
- UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
- ret = BuildDrbToBeModifiedList(ueId, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
- value.choice.DRBs_ToBeModified_List));
+ ieIdx++;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
+ UEContextModificationRequestIEs__value_PR_RRCContainer;
+ if(fillRrcReconfigBuf(ueCb, &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer, true) != ROK)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to fill Rrc reconfiguration buffer");
+ return RFAILED;
+ }
- /* TODO: DRB to be release list */
-
- if(ret != ROK)
- {
- break;
+ /* RRC delivery status request */
+ ieIdx++;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
}
+
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);
+ 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 ueContextModifyReq structure (at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- break;
+ DU_LOG("\nERROR --> F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
}
else
{
- DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
- for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
- {
- DU_LOG("%x",encBuf[ieIdx]);
- }
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
+#if 0
+ /* This for loop was going into an infinite loop even though encBufSize
+ * has a small value. Hence commented this
+ */
+ for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
+ {
+ DU_LOG("%x",encBuf[ieIdx]);
+ }
+#endif
}
- if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
+ /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
+ if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
{
- DU_LOG("\nERROR --> F1AP : Sending Ue context modification request failed");
- break;
+ DU_LOG("\nERROR --> F1AP : Sending Ue context modification request failed");
+ break;
}
ret = ROK;
FreeUeContextModicationRequest(f1apMsg);
return ret;
}
+
/*****************************************************************i
-*
+ *
* @brief Free memory allocated for UE Context Release Command
*
* @details
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendUeContextReleaseCommand(uint8_t cuUeF1apId, uint8_t duUeF1apId)
+uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
{
bool memAllocFailed = false;
- uint8_t ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
+ uint8_t duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
+ DuDb *duDb;
+ CuUeCb *ueCb;
F1AP_PDU_t *f1apMsg = NULLP;
UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
- elementCnt = 4;
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ ueCb = &duDb->ueCb[duUeF1apId-1];
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ elementCnt = 3;
+ else
+ elementCnt = 4;
+
ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
{
break;
}
+
ieIdx=0;
ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
+ /* Cause of UE context release */
ieIdx++;
ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
- UEContextReleaseCommandIEs__value_PR_Cause;
+ UEContextReleaseCommandIEs__value_PR_Cause;
ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
- CauseRadioNetwork_normal_release;
-
- /* RRC Container for RRC release */
- ieIdx++;
- ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
- ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
- ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
- UEContextReleaseCommandIEs__value_PR_RRCContainer;
- char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
- bufLen =7;
- ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
- CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
- ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
- if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
- break;
+ CauseRadioNetwork_normal_release;
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ {
+ /* RRC Container for RRC release */
+ ieIdx++;
+ ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
+ ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
+ ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
+ UEContextReleaseCommandIEs__value_PR_RRCContainer;
+ char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
+ bufLen =7;
+ ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
+ CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
+ ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
+ if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
+ break;
+ }
+ memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
+ memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
}
- memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
- memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
-
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the UE Context Release Command type as APER */
}
}
- if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
+ /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
+ if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
{
DU_LOG("\nERROR --> F1AP : Sending Ue context Release Command failed");
break;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t procUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
+uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
{
uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
break;
}
}
- if(BuildAndSendUeContextReleaseCommand(cuUeF1apId, duUeF1apId) != ROK)
+
+ if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
{
DU_LOG("\nERROR --> F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
return RFAILED;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t procGnbDuUpdate(F1AP_PDU_t *f1apMsg)
+uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
{
bool cellToBeDelete = false;
- uint8_t ieIdx = 0, ueIdx = 0;
+ uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
+ uint16_t nrCellId;
+ DuDb *duDb;
+ CuCellCb *cellCb;
GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
break;
case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
{
+ struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
+ (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
+ Served_Cells_To_Delete_List.list.array[0];
+ bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
cellToBeDelete = true;
break;
}
break;
}
}
- if(BuildAndSendDUUpdateAck() != ROK)
+ if(BuildAndSendDUUpdateAck(duId) != ROK)
{
DU_LOG("ERROR --> F1AP : Failed to build and send DUUpdateAck");
return RFAILED;
#endif
if(cellToBeDelete == true)
{
- for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
+ if(cellCb->numUe == 0)
{
- CU_FREE(ueCb[ueIdx].f1apMsgDb.duToCuContainer.buf, ueCb[ueIdx].f1apMsgDb.duToCuContainer.size);
- memset(&ueCb[ueIdx], 0, sizeof(UeCb));
+ memset(cellCb, 0, sizeof(CuCellCb));
+ duDb->numCells--;
}
+ else
+ cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
}
-
return ROK;
}
{
if(sliceSupportList->list.array)
{
- cuCfgParams.numSnssaiSupported = sliceSupportList->list.count;
+ cuCb.numSnssaiSupported = sliceSupportList->list.count;
for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
{
if(sliceSupportList->list.array[sliceListIdx])
{
- CU_ALLOC(cuCfgParams.snssaiList[sliceListIdx], sizeof(Snssai));
- if(cuCfgParams.snssaiList[sliceListIdx] == NULLP)
+ CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
+ if(cuCb.snssaiList[sliceListIdx] == NULLP)
{
DU_LOG("\nERROR --> CU_STUB: buildSliceList(): Memory allocation failed");
return RFAILED;
}
if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
{
- memcpy(&cuCfgParams.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
+ memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
}
if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
{
- memcpy(&cuCfgParams.snssaiList[sliceListIdx]->sd,\
+ memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
}
return ROK;
}
+/****************************************************************
+ * @brief Function to process Srb Setup Mod List
+ *
+ * @details
+ *
+ * Function : procSrbSetupModList
+ *
+ * Functionality:
+ * - Function to process SRB Setup Mod List
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
+{
+ uint8_t arrIdx = 0, srbIdx;
+ struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
+
+ if(srbSetupList != NULLP)
+ {
+ for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
+ {
+ srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
+ if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
+ {
+ for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
+ {
+ if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
+ {
+ ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
+ break;
+ }
+ }
+ }
+
+ }
+ }
+ return ROK;
+}
+
+
/****************************************************************
* @brief Function to process Drb Setup Mod List
*
* RFAILED - failure
*
* ****************************************************************/
-uint8_t procDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
+uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
{
- uint8_t arrIdx = 0;
+ uint8_t arrIdx = 0, drbIdx;
uint32_t teId = 0;
struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
{
+ for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
+ {
+ if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
+ {
+ if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
+ ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
+ break;
+ }
+ }
+
+ if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
+ {
/* extracting teId */
teId = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
if(teId > 0)
{
- if(addDrbTunnels(teId)== ROK)
+ if(addDrbTunnels(duId, teId)== ROK)
{
DU_LOG("\nDEBUG --> EGTP: Tunnel Added for TeId %d", teId);
}
}
else
return RFAILED;
+ }
}
}
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t procUeContextModificationResponse(F1AP_PDU_t *f1apMsg)
+uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
{
- uint8_t idx, duUeF1apId;
- UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
+ uint8_t idx=0, duIdx=0;
+ uint8_t duUeF1apId = 0, cuUeF1apId = 0;
+ DuDb *duDb = NULLP;
+ CuUeCb *ueCb = NULLP;
+ UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
{
switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
{
+ case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
+ {
+ cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
+ break;
+ }
case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
{
duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
+ ueCb = &duDb->ueCb[duUeF1apId-1];
break;
}
case ProtocolIE_ID_id_DRBs_SetupMod_List:
{
/* Adding Tunnels for successful DRB */
- procDrbSetupModList(&ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
+ procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
break;
}
+ case ProtocolIE_ID_id_SRBs_SetupMod_List:
+ {
+ procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
+ break;
+ }
+ case ProtocolIE_ID_id_DUtoCURRCInformation:
+ {
+ DU_LOG("\nINFO --> Received Du to Cu RRC Information ");
+ if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
+ DUtoCURRCInformation.cellGroupConfig)) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract Du to Cu RRC Information");
+ return RFAILED;
+ }
+ break;
+ }
+
+ }
+ }
+
+ /* If UE is in handover and UE context is not yet created at target DU, then send
+ * UE context setup request to target DU */
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ {
+ uint8_t ueIdx = 0;
+ DuDb *tgtDuDb = NULLP;
+ CuUeCb *ueCbInTgtDu = NULLP;
+
+ SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
+ if(tgtDuDb)
+ {
+ /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
+ * not known here, using CU UE F1AP ID to search for UE Cb in target DU
+ * DB */
+ for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
+ {
+ if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
+ {
+ ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
+ break;
+ }
+ }
+
+ /* If UE context is not found in Target DU DU, send UE context setup
+ * request */
+ if(ueCbInTgtDu == NULLP)
+ {
+ if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb)) != ROK)
+ {
+ DU_LOG("\nERROR -> F1AP : Failed at BuildAndSendUeContextSetupReq");
+ return RFAILED;
+ }
+ }
}
}
+
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-void procF1SetupReq(F1AP_PDU_t *f1apMsg)
+void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
{
- uint8_t ieIdx = 0, plmnidx=0, ret=ROK;
+ uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
+ uint32_t duId = 0;
+ uint64_t nrCellId = 0;
+ DuDb *duDb = NULLP;
+ CuCellCb *cellCb = NULLP;
BIT_STRING_t nrcellIdentity;
F1SetupRequest_t *f1SetupReq = NULLP;
GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
{
switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
{
+ case ProtocolIE_ID_id_gNB_DU_ID:
+ {
+ duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ duDb = &cuCb.duInfo[cuCb.numDu];
+ memset(duDb, 0, sizeof(DuDb));
+ duDb->duId = duId;
+ cuCb.numDu++;
+ *destDuId = duId;
+ }
+ else
+ return;
+ break;
+ }
+ case ProtocolIE_ID_id_gNB_DU_Name:
+ {
+ strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
+ break;
+ }
case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
{
duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
srvCellItem = &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
+
+ bitStringToInt(&nrcellIdentity, &nrCellId);
+ SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
+ if(cellCb == NULLP)
+ {
+ cellCb = &duDb->cellCb[duDb->numCells];
+ memset(cellCb, 0, sizeof(CuCellCb));
+ cellCb->nrCellId = nrCellId;
+ cellCb->cellStatus = CELL_ACTIVE;
+ duDb->numCells++;
+ }
}
}
}
}
if(ret == ROK)
{
- BuildAndSendF1SetupRsp(&nrcellIdentity);
+ BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
}
else
{
}
}
+/****************************************************************
+*
+* @brief processing of UE Context Release Complete
+*
+* @details
+*
+* Function : procUeContextReleaseComplete
+*
+* Functionality:
+* - processing of UE Context Release Complete
+*
+* @params[in] F1AP_PDU_t *f1apMsg
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
+{
+ uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0, drbIdx = 0;
+ uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
+ DuDb *duDb = NULLP;
+ CuUeCb *ueCb = NULLP;
+ UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(!duDb)
+ {
+ DU_LOG("\nERROR --> F1AP : No entry found for DU ID [%d]", duId);
+ return;
+ }
+
+ ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
+ for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
+ {
+ switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
+ {
+ gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
+ break;
+ }
+ case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
+ {
+ gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
+ ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
+ for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
+ {
+ if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
+ {
+ if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
+ (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
+ {
+ for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
+ {
+ deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
+ }
+ ueCb->cellCb->ueCb[ueIdx] = NULLP;
+ ueCb->cellCb->numUe--;
+ if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus == CELL_DELETION_IN_PROGRESS))
+ {
+ memset(ueCb->cellCb, 0, sizeof(CuCellCb));
+ duDb->numCells--;
+ }
+ break;
+ }
+ }
+ }
+ memset(ueCb, 0, sizeof(CuUeCb));
+ duDb->numUe--;
+ break;
+ }
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Builds the Paging cell list
+ *
+ * @details
+ *
+ * Function : BuildPagingCellList
+ *
+ * Functionality: Build the paging cell list
+ *
+ * @params[in] PagingCell_list_t *pagingCelllist,
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
+{
+ uint8_t cellIdx =0;
+ PagingCell_ItemIEs_t *pagingCellItemIes;
+ PagingCell_Item_t *pagingCellItem;
+
+ pagingCelllist->list.count = numCells;
+ pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
+ CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
+ if(pagingCelllist->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildPagingCellList(): Memory allocation failed ");
+ return RFAILED;
+ }
+
+ for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
+ {
+ CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
+ if(pagingCelllist->list.array[cellIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildPagingCellList(): Memory allocation failed ");
+ return RFAILED;
+ }
+ }
+
+ for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
+ {
+ pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
+ pagingCellItemIes->id = ProtocolIE_ID_id_PagingCell_Item;
+ pagingCellItemIes->criticality = Criticality_ignore;
+ pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
+ pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
+
+ /* Fill NrCgi Information */
+ BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Deallocation of memory allocated in paging msg
+ *
+ * @details
+ *
+ * Function :FreePagingMsg
+ *
+ * Functionality: Deallocation of memory allocated in paging msg
+ *
+ * @params[in] F1AP_PDU_t *f1apMsg
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void FreePagingMsg(F1AP_PDU_t *f1apMsg)
+{
+ uint8_t ieIdx, cellIdx;
+ Paging_t *paging;
+ PagingCell_ItemIEs_t *pagingCellItemIes;
+ PagingCell_Item_t *pagingCellItem;
+ PagingCell_list_t *pagingCelllist;
+
+ if(f1apMsg)
+ {
+ if(f1apMsg->choice.initiatingMessage)
+ {
+ paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
+ if(paging->protocolIEs.list.array)
+ {
+ for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
+ {
+ if(paging->protocolIEs.list.array[ieIdx])
+ {
+ switch(paging->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_ID_id_UEIdentityIndexValue:
+ {
+ CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
+ paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
+ break;
+ }
+
+ case ProtocolIE_ID_id_PagingIdentity:
+ {
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
+ {
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
+ {
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
+ {
+ CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
+ }
+ CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
+ sizeof(struct CNUEPagingIdentity));
+ }
+ }
+ break;
+ }
+
+ case ProtocolIE_ID_id_PagingCell_List:
+ {
+ pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
+ if(pagingCelllist->list.array)
+ {
+ for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
+ {
+ if(pagingCelllist->list.array[cellIdx])
+ {
+ pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
+ if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
+ {
+ pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
+ CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
+ CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
+ }
+ CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
+ }
+ }
+ CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
+ }
+ break;
+ }
+ }
+ CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
+ }
+ }
+ CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
+ }
+ CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
+ }
+ CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
+ }
+}
+/*******************************************************************
+ *
+ * @brief Builds and sends the paging message if UE is in idle mode
+ *
+ * @details
+ *
+ * Function : BuildAndSendPagingMsg
+ *
+ * Functionality: Builds and sends the paging message
+ *
+ * @params[in] uint32_t duId, uint8_t gsTmsi
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
+{
+ bool memAllocFailed = false;
+ uint8_t ieIdx = 0, elementCnt = 0, ret = RFAILED;
+ uint16_t ueId = 0, duIdx = 0;
+
+ /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
+ *5G-S-TMSI :48 Bits >> 6 Bytes and 0 UnusedBits */
+ uint8_t totalByteInUeId = 2, totalByteInTmsi = 6;
+ uint8_t unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
+
+ F1AP_PDU_t *f1apMsg = NULLP;
+ Paging_t *paging = NULLP;
+ DuDb *duDb;
+ asn_enc_rval_t encRetVal;
+
+ DU_LOG("\nINFO --> F1AP : Building PAGING Message command\n");
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): DuDb is empty");
+ return ret;
+ }
+
+ while(true)
+ {
+ CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
+ if(f1apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
+ break;
+ }
+
+ f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
+
+ CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
+ if(f1apMsg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
+ break;
+ }
+ f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
+ f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
+ f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
+
+ paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
+
+ elementCnt = 5;
+ paging->protocolIEs.list.count = elementCnt;
+ paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
+
+ /* Initialize the Paging Message members */
+ CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
+ if(paging->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg():Memory allocation failed");
+ break;
+ }
+
+ for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
+ {
+ CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
+ if(paging->protocolIEs.list.array[ieIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ memAllocFailed = true;
+ break;
+ }
+ }
+
+ if(memAllocFailed == true)
+ {
+ break;
+ }
+
+ /* UE Identity Index Value */
+ ieIdx=0;
+ paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
+ paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
+ paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
+ paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
+ CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
+ paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ break;
+ }
+
+ /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
+ ueId = gsTmsi % 1024;
+ fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
+
+ /* Paging Identity */
+ ieIdx++;
+ paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
+ paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
+ PagingIdentity_PR_cNUEPagingIdentity;
+ CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
+ sizeof(struct CNUEPagingIdentity));
+ if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ break;
+ }
+
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
+ CNUEPagingIdentity_PR_fiveG_S_TMSI;
+
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
+ CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
+ if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ break;
+ }
+
+ fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
+ unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
+
+ /* Paging Drx */
+ ieIdx++;
+ paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
+ paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
+ paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
+
+ /* Paging Priority */
+ ieIdx++;
+ paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
+ paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
+ paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
+
+ /* Paging Cell List */
+ ieIdx++;
+ paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
+ paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
+ paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
+ if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
+ break;
+ }
+
+ xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
+
+ /* Encode the UE Context Release Command 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 Release Command structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for Paging\n");
+ for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
+ {
+ DU_LOG("%x",encBuf[ieIdx]);
+ }
+ }
+
+ if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Sending Ue context Release Command failed");
+ break;
+ }
+
+ ret = ROK;
+ break;
+
+ }
+
+ FreePagingMsg(f1apMsg);
+ return ret;
+}
+
/*******************************************************************
*
* @brief Handles received F1AP message and sends back response
* RFAILED - failure
*
* ****************************************************************/
-void F1APMsgHdlr(Buffer *mBuf)
+void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
{
int i;
char *recvBuf;
case InitiatingMessage__value_PR_F1SetupRequest:
{
DU_LOG("\nINFO --> F1AP : F1 setup request received");
- procF1SetupReq(f1apMsg);
+ procF1SetupReq(duId, f1apMsg);
break;
}
case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
{
DU_LOG("\nINFO --> F1AP : GNB-DU config update received");
- procGnbDuUpdate(f1apMsg);
+ procGnbDuUpdate(*duId, f1apMsg);
break;
}
case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
{
DU_LOG("\nINFO --> F1AP : Received InitialULRRCMessageTransfer");
- procInitULRRCMsg(f1apMsg);
+ procInitULRRCMsg(*duId, f1apMsg);
break;
}
case InitiatingMessage__value_PR_ULRRCMessageTransfer:
{
DU_LOG("\nINFO --> F1AP : Received ULRRCMessageTransfer");
- procUlRrcMsg(f1apMsg);
+ procUlRrcMsg(*duId, f1apMsg);
break;
}
case InitiatingMessage__value_PR_UEContextReleaseRequest:
{
DU_LOG("\nINFO --> F1AP : Received UE Context Release Request");
- procUeContextReleaseReq(f1apMsg);
+ procUeContextReleaseReq(*duId, f1apMsg);
break;
}
default:
case SuccessfulOutcome__value_PR_UEContextSetupResponse:
{
DU_LOG("\nINFO --> F1AP : UE ContextSetupResponse received");
- procUeContextSetupResponse(f1apMsg);
+ procUeContextSetupResponse(*duId, f1apMsg);
break;
}
case SuccessfulOutcome__value_PR_UEContextModificationResponse:
{
DU_LOG("\nINFO --> F1AP : UE Context Modification Response received");
- procUeContextModificationResponse(f1apMsg);
+ procUeContextModificationResponse(*duId, f1apMsg);
break;
}
case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
{
DU_LOG("\nINFO --> F1AP : UE Context release complete received");
+ procUeContextReleaseComplete(*duId, f1apMsg);
break;
}
default:
Code Review / o-du / l2.git / blobdiff