X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fcu_stub%2Fcu_f1ap_msg_hdl.c;h=1b256b43a37d7cfd6a009be0a537ea26daeb1765;hb=ed6746a6081339633c3baa314251fcc11b98ce10;hp=0cfc141f4bed1e1e691019702550cdeb7af4e9c0;hpb=d18338bde70b043c3dde28b7d88d128c0b138380;p=o-du%2Fl2.git diff --git a/src/cu_stub/cu_f1ap_msg_hdl.c b/src/cu_stub/cu_f1ap_msg_hdl.c index 0cfc141f4..1b256b43a 100644 --- a/src/cu_stub/cu_f1ap_msg_hdl.c +++ b/src/cu_stub/cu_f1ap_msg_hdl.c @@ -27,6 +27,17 @@ #include #include "ProtocolExtensionField.h" #include "F1AP-PDU.h" +#include "ModulationOrder.h" +#include "BandNR.h" +#include "UE-CapabilityRAT-Container.h" +#include "UE-CapabilityRAT-ContainerList.h" +#include "UE-CapabilityRAT-ContainerListRRC.h" +#include "SupportedBandwidth.h" +#include "FeatureSetUplinkPerCC.h" +#include "FeatureSetDownlinkPerCC.h" +#include "FeatureSets.h" +#include "RF-Parameters.h" +#include "UE-NR-Capability.h" #include "ProtocolExtensionContainer.h" #include "CellGroupConfigRrc.h" #include "MAC-CellGroupConfig.h" @@ -1512,20 +1523,55 @@ uint8_t fillDlDcchRrcMsg(RRCContainer_t *rrcContainer) uint8_t BuildDLRRCContainer(uint8_t rrcMsgType, RRCContainer_t *rrcContainer) { - uint8_t ret = ROK; - + uint8_t ret, bufLen; + + ret =ROK; if(rrcMsgType == RRC_SETUP) { ret = fillDlCcchRrcMsg(rrcContainer); if(ret == RFAILED) - DU_LOG("\n F1AP: Failed to fill DL-CCCH Msg at BuildDLRRCContainer()"); + DU_LOG("\n F1AP: Failed to fill DL-CCCH Msg at RRC SETUP"); + } + else if(rrcMsgType == REGISTRATION_ACCEPT) + { + /*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; + rrcContainer->size = bufLen; + CU_ALLOC(rrcContainer->buf, rrcContainer->size); + if(rrcContainer->buf != NULLP) + { + memset(rrcContainer->buf, 0, bufLen); + memcpy(rrcContainer->buf, buf, bufLen); + } } else if(rrcMsgType == RRC_RECONFIG) { - ret = fillDlDcchRrcMsg(rrcContainer); - if(ret == RFAILED) - DU_LOG("\n F1AP: Failed at fill DL-DCCH Msg at BuildDLRRCContainer()"); + /*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; + rrcContainer->size = bufLen; + CU_ALLOC(rrcContainer->buf, rrcContainer->size); + if(rrcContainer->buf != NULLP) + { + memset(rrcContainer->buf, 0, bufLen); + memcpy(rrcContainer->buf, buf, bufLen); + } } + return ret; } @@ -1546,7 +1592,7 @@ uint8_t BuildDLRRCContainer(uint8_t rrcMsgType, RRCContainer_t *rrcContainer) * RFAILED - failure * * ****************************************************************/ -uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t rrcMsgType) +uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t srbId, uint8_t rrcMsgType) { uint8_t elementCnt = 0; uint8_t ieId; @@ -1635,7 +1681,7 @@ uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t rrcMsgType) 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 = SRB0; + dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId; /* RRCContainer */ idx++; @@ -1704,8 +1750,14 @@ uint8_t setDlRRCMsgType() case RRC_SETUP: rrcMsgType = RRC_SETUP; break; - case RRC_SECURITY_MODE_COMMAND: - rrcMsgType = RRC_SECURITY_MODE_COMMAND; + case REGISTRATION_ACCEPT: + rrcMsgType = REGISTRATION_ACCEPT; + break; + case UE_CONTEXT_SETUP_REQ: + rrcMsgType = UE_CONTEXT_SETUP_REQ; + break; + case SECURITY_MODE_COMPLETE: + rrcMsgType = SECURITY_MODE_COMPLETE; break; case RRC_RECONFIG: rrcMsgType = RRC_RECONFIG; @@ -1788,7 +1840,7 @@ uint8_t procInitULRRCMsg(F1AP_PDU_t *f1apMsg) { f1apMsgDb.dlRrcMsgCount++; rrcMsgType = setDlRRCMsgType(); - ret = BuildAndSendDLRRCMessageTransfer(rrcMsgType); + ret = BuildAndSendDLRRCMessageTransfer(SRB0, rrcMsgType); } return ret; } @@ -5560,6 +5612,452 @@ uint8_t fillCellGrpCfg(CellGroupConfig_t *cellGrp) return ROK; } +/******************************************************************* + * + * @brief Free UE Capability RAT container + * + * @details + * + * Function : freeUeCapRatCont + * + * Functionality: + * Free UE Capability RAT conatiner + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap) +{ + uint8_t idx; + FeatureSets_t *featureSets; + + if(ueNrCap->rf_Parameters.supportedBandListNR.list.array) + { + for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++) + { + if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx]) + CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR)); + } + CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size); + } + + if(ueNrCap->featureSets) + { + featureSets = ueNrCap->featureSets; + if(featureSets->featureSetsDownlinkPerCC) + { + if(featureSets->featureSetsDownlinkPerCC->list.array) + { + for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++) + { + if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) + CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \ + sizeof(ModulationOrder_t)); + CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC)); + } + CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size); + } + CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC)); + } + + if(featureSets->featureSetsUplinkPerCC) + { + if(featureSets->featureSetsUplinkPerCC->list.array) + { + for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++) + { + if(featureSets->featureSetsUplinkPerCC->list.array[idx]) + { + if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) + CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\ + sizeof(ModulationOrder_t)); + CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC)); + } + } + CU_FREE(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size); + } + CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC)); + } + CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets)); + } +} + +/******************************************************************* + * + * @brief Free UE capability RAT container list + * + * @details + * + * Function : freeUeCapRatContList + * + * Functionality: Free UE capability RAT container list + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList) +{ + uint8_t idx; + if(ueCapablityList->list.array) + { + for(idx = 0; idx < ueCapablityList->list.count; idx++) + { + if(ueCapablityList->list.array[idx]) + CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t)); + } + CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size); + } +} + +/******************************************************************* + * + * @brief Fill feature sets + * + * @details + * + * Function : fillFeatureSets + * + * Functionality: Fill feature sets + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t fillFeatureSets(FeatureSets_t *featureSets) +{ + uint8_t idx, elementCnt; + + featureSets->featureSetsDownlink = NULLP; + CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC)); + if(!featureSets->featureSetsDownlinkPerCC) + { + DU_LOG("\nMemory allocation failed in fillFeatureSets"); + return RFAILED; + } + + elementCnt = 1; + featureSets->featureSetsDownlinkPerCC->list.count = elementCnt; + featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *); + CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size); + if(!featureSets->featureSetsDownlinkPerCC->list.array) + { + DU_LOG("\nMemory allocation failed in fillFeatureSets"); + return RFAILED; + } + + for(idx = 0; idx < elementCnt; idx++) + { + CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC)); + if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]) + { + DU_LOG("\nMemory allocation failed in fillFeatureSets"); + return RFAILED; + } + } + + idx = 0; + featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15; + featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1; + featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20; + featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP; + featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP; + + CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t)); + if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) + { + DU_LOG("\nMemory allocation failed in fillFeatureSets"); + return RFAILED; + } + *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64; + + featureSets->featureSetsUplink = NULLP; + CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC)); + if(!featureSets->featureSetsUplinkPerCC) + { + DU_LOG("\nMemory allocation failed in fillFeatureSets"); + return RFAILED; + } + + elementCnt = 1; + featureSets->featureSetsUplinkPerCC->list.count = elementCnt; + featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *); + CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size); + if(!featureSets->featureSetsUplinkPerCC->list.array) + { + DU_LOG("\nMemory allocation failed in fillFeatureSets"); + return RFAILED; + } + + for(idx = 0; idx < elementCnt; idx++) + { + CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC)); + if(!featureSets->featureSetsUplinkPerCC->list.array[idx]) + { + DU_LOG("\nMemory allocation failed in fillFeatureSets"); + return RFAILED; + } + } + + idx = 0; + featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15; + featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1; + featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20; + featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP; + featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP; + featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP; + + CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t)); + if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) + { + DU_LOG("\nMemory allocation failed in fillFeatureSets"); + return RFAILED; + } + *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16; + + return ROK; +} + +/******************************************************************* + * + * @brief Fill UE capability RAT container + * + * @details + * + * Function : fillUeCapRatCont + * + * Functionality: Fill UE capability RAT container + * + * @params[in] UE Capability RAT container buffer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf) +{ + uint8_t ret = ROK; + uint8_t idx, elementCnt; + asn_enc_rval_t encRetVal; + UE_NR_Capability_t ueNrCap; + + while(true) + { + ueNrCap.accessStratumRelease = AccessStratumRelease_rel15; + + /* Filling PDCP parameters */ + ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false; + ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false; + ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false; + ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false; + ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false; + ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false; + ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false; + ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false; + ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false; + ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false; + ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2; + ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP; + ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP; + ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP; + ueNrCap.pdcp_Parameters.shortSN = NULLP; + ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP; + ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP; + + ueNrCap.rlc_Parameters = NULLP; + ueNrCap.mac_Parameters = NULLP; + + /* Filling PHY parameters */ + ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP; + ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP; + ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP; + ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP; + ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP; + + /* Filling RF parameters */ + elementCnt = 1; + ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt; + ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *); + CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size); + if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array) + { + DU_LOG("\nMemory allocation failed in fillUeCapRatCont"); + ret = RFAILED; + break; + } + + for(idx = 0; idx < elementCnt; idx++) + { + CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR)); + if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]) + { + ret = RFAILED; + break; + } + } + if(ret == RFAILED) + break; + + idx = 0; + ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1; + ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP; + ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP; + + ueNrCap.measAndMobParameters = NULLP; + ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP; + ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP; + ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP; + ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP; + ueNrCap.featureSets = NULLP; + + CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets)); + if(!ueNrCap.featureSets) + { + DU_LOG("\nMemory allocation failed in fillUeCapRatCont"); + ret = RFAILED; + break; + } + + if(fillFeatureSets(ueNrCap.featureSets) != ROK) + { + DU_LOG("\nfillDLFeatureSets() failed "); + ret = RFAILED; + break; + } + + ueNrCap.featureSetCombinations = NULLP; + ueNrCap.lateNonCriticalExtension = NULLP; + ueNrCap.nonCriticalExtension = NULLP; + + /* encode UE Capability RAT Container List into duToCuRrcContainer */ + xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap); + cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf); + + /* Encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG( "\n F1AP : Could not encode UE Capability RAT Container (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\n F1AP : Created APER encoded buffer for UE Capability RAT Container\n"); + for(int i=0; i< encBufSize; i++) + { + printf("%x",encBuf[i]); + } + } + + ueCapRatContBuf->size = encBufSize; + CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size); + if(!ueCapRatContBuf->buf) + { + DU_LOG("\nF1AP : Memory allocation failed in fillUeCapabilityContainer"); + break; + } + memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size); + ret = ROK; + break; + } + freeUeCapRatCont(&ueNrCap); + return ROK; +} + +/******************************************************************* + * + * @brief Fill UE Capability RAT container list + * + * @details + * + * Function : fillUeCapRatContList + * + * Functionality: Fill UE Capability RAT container list + + * + * @params[in] UE capability RAT container list buffer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf) +{ + 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 *); + + CU_ALLOC(ueCapablityList.list.array, ueCapablityList.list.size); + if(!ueCapablityList.list.array) + { + DU_LOG("\nMemory allocation failed in fillUeCapRatContList"); + ret = RFAILED; + break; + } + + for(idx=0; idxrat_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( "\n F1AP : Could not encode UE Capability RAT Container (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\n F1AP : Created APER encoded buffer for UE Capability RAT Container\n"); + for(int i=0; i< encBufSize; i++) + { + printf("%x",encBuf[i]); + } + } + + ueCapablityListBuf->size = encBufSize; + CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size); + if(!ueCapablityListBuf->buf) + { + DU_LOG("\nF1AP : Memory allocation failed in fillUeCapabilityContainer"); + break; + } + memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size); + ret = ROK; + break; + } + freeUeCapRatContList(&ueCapablityList); + return ROK; +} + /******************************************************************* * * @brief Fills CuToDuContainer @@ -5583,10 +6081,18 @@ uint8_t fillCuToDuContainer(CUtoDURRCInformation_t *rrcMsg) uint8_t ret = ROK; uint8_t idx, idx2, rrcBufLen; - elementCnt = 1; + CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t)); + if(!rrcMsg->uE_CapabilityRAT_ContainerList) + { + DU_LOG(" F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed"); + return RFAILED; + } + ret = fillUeCapRatContList(rrcMsg->uE_CapabilityRAT_ContainerList); + 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); @@ -5639,6 +6145,12 @@ 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) @@ -5700,7 +6212,7 @@ uint8_t BuildAndSendUeContextSetupReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \ uint8_t SplCellListret; uint8_t SrbSetupret; uint8_t elementCnt; - uint8_t idx; + uint8_t idx, bufLen; uint8_t idx1; F1AP_PDU_t *f1apMsg = NULLP; UEContextSetupRequest_t *ueSetReq = NULLP; @@ -5735,7 +6247,7 @@ uint8_t BuildAndSendUeContextSetupReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \ ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest; - elementCnt = 11; + elementCnt = 12; ueSetReq->protocolIEs.list.count = elementCnt; ueSetReq->protocolIEs.list.size = \ elementCnt * sizeof(UEContextSetupRequestIEs_t *); @@ -5858,14 +6370,15 @@ uint8_t BuildAndSendUeContextSetupReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \ { break; } - - /* RRC Container */ + /* 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; - ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = rrcContLen; + 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) @@ -5873,8 +6386,8 @@ uint8_t BuildAndSendUeContextSetupReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \ DU_LOG(" F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed"); break; } - memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \ - rrcContainer, ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size); + 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++; @@ -5885,7 +6398,27 @@ uint8_t BuildAndSendUeContextSetupReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \ 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) + { + DU_LOG(" 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 */ @@ -5990,13 +6523,27 @@ uint8_t procUlRrcMsg(F1AP_PDU_t *f1apMsg) { f1apMsgDb.dlRrcMsgCount++; rrcMsgType = setDlRRCMsgType(); - if(rrcMsgType == RRC_SECURITY_MODE_COMMAND) + if(rrcMsgType == REGISTRATION_ACCEPT) { - ret = BuildAndSendUeContextSetupReq(cuUeF1apId, duUeF1apId, rrcContLen, rrcContainer); + DU_LOG("\nF1AP: Sending DL RRC MSG for RRC Registration Accept"); + ret = BuildAndSendDLRRCMessageTransfer(srbId, rrcMsgType); } - if(rrcMsgType == RRC_RECONFIG) + if(rrcMsgType == UE_CONTEXT_SETUP_REQ) { - ret = BuildAndSendDLRRCMessageTransfer(rrcMsgType); + DU_LOG("\nF1AP: Sending Ue Context Setup Req"); + ret = BuildAndSendUeContextSetupReq(cuUeF1apId, duUeF1apId,\ + rrcContLen, rrcContainer); + } + if(rrcMsgType == SECURITY_MODE_COMPLETE) + { + /* To trigger the DL RRC Msg for RRC Reconfig */ + f1apMsgDb.dlRrcMsgCount++; + rrcMsgType = setDlRRCMsgType(); + if(rrcMsgType == RRC_RECONFIG) + { + DU_LOG("\nF1AP: Sending DL RRC MSG for RRC Reconfig"); + BuildAndSendDLRRCMessageTransfer(srbId, rrcMsgType); + } } } return ret; @@ -6291,6 +6838,7 @@ void F1APMsgHdlr(Buffer *mBuf) case SuccessfulOutcome__value_PR_UEContextSetupResponse: { DU_LOG("\nF1AP : UE ContextSetupResponse received"); + f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */ break; } default: