#include<ProtocolIE-Field.h>
#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"
S16 BuildNrCellId(BIT_STRING_t *nrcell)
{
- U8 tmp;
- for (tmp = 0 ; tmp < nrcell->size-1; tmp++)
- {
- nrcell->buf[tmp] = 0;
- }
+ memset(nrcell->buf, 0, nrcell->size);
nrcell->buf[4] = 16;
nrcell->bits_unused = 4;
nrcell->size = 5 * sizeof(uint8_t);
* ****************************************************************/
S16 BuildAndSendF1SetupRsp()
{
- U8 idx,ieIdx;
- U8 elementCnt,cellCnt;
+ uint8_t idx,ieIdx;
+ uint8_t elementCnt,cellCnt;
F1AP_PDU_t *f1apMsg = NULL;
F1SetupResponse_t *f1SetupRsp;
GNB_CU_Name_t *cuName;
rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
rrcVer->latest_RRC_Version.size = RRC_SIZE;
- CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
if(rrcVer->latest_RRC_Version.buf == NULLP)
{
CU_FREE(cuName->buf, sizeof(cuName->size));
CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
if(rrcVer->iE_Extensions == NULLP)
{
- CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
{
CU_FREE(rrcVer->iE_Extensions,\
sizeof(ProtocolExtensionContainer_4624P81_t));
- CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
sizeof(struct RRC_Version_ExtIEs *));
CU_FREE(rrcVer->iE_Extensions,\
sizeof(ProtocolExtensionContainer_4624P81_t));
- CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
- Latest_RRC_Version_Enhanced.size = 3*sizeof(U8);
+ Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
CU_ALLOC(rrcVer->iE_Extensions->list.\
array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
- 3*sizeof(U8));
+ 3*sizeof(uint8_t));
if(rrcVer->iE_Extensions->list.\
array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
{
sizeof(struct RRC_Version_ExtIEs *));
CU_FREE(rrcVer->iE_Extensions,\
sizeof(ProtocolExtensionContainer_4624P81_t));
- CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
/* Clean up */
- CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(idx=0; idx<elementCnt; idx++)
{
S16 BuildAndSendDUUpdateAck()
{
- U8 idx;
- U8 elementCnt;
+ uint8_t idx;
+ uint8_t elementCnt;
F1AP_PDU_t *f1apMsg = NULL;
GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
asn_enc_rval_t enRetVal; /* Encoder return value */
{
/* encode DL-DCCH message into RRC Container */
xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ 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 */
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;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t rrcMsgType)
+uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t srbId, uint8_t rrcMsgType)
{
uint8_t elementCnt = 0;
uint8_t ieId;
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 = SRB1;
+ dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
/* RRCContainer */
idx++;
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;
{
f1apMsgDb.dlRrcMsgCount++;
rrcMsgType = setDlRRCMsgType();
- ret = BuildAndSendDLRRCMessageTransfer(rrcMsgType);
+ ret = BuildAndSendDLRRCMessageTransfer(SRB0, rrcMsgType);
}
return ret;
}
uint8_t BuildNrcgi(NRCGI_t *nrcgi)
{
uint8_t ret;
- uint8_t unused = 4;
+ uint8_t unused_bits = 4;
uint8_t byteSize = 5;
- uint8_t val = 16;
+ uint8_t val = 1;
/* Allocate Buffer Memory */
nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
{
return RFAILED;
}
+#if 0
ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
if(ret != ROK)
{
return RFAILED;
}
+#endif
+ memset(nrcgi->nRCellIdentity.buf, 0, nrcgi->nRCellIdentity.size);
+ nrcgi->nRCellIdentity.buf[0] |= val;
+ nrcgi->nRCellIdentity.bits_unused = unused_bits;
+
return ROK;
}
/*******************************************************************
if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
!=NULLP)
{
- CU_ALLOC(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
+ CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
gTPTunnel->gTP_TEID.size);
}
case ProtocolIE_ID_id_RRCContainer:
if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
{
- CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
+ CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
}
break;
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; idx<elementCnt; idx++)
+ {
+ CU_ALLOC(ueCapablityList.list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
+ if(ueCapablityList.list.array[idx] == NULLP)
+ {
+ DU_LOG("\nMemory allocation failed in fillUeCapRatContList");
+ ret = RFAILED;
+ 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( "\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
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);
{
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)
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;
ueSetReq =
&f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
- elementCnt = 11;
+ elementCnt = 12;
ueSetReq->protocolIEs.list.count = elementCnt;
ueSetReq->protocolIEs.list.size = \
elementCnt * sizeof(UEContextSetupRequestIEs_t *);
{
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)
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++;
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 */
{
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;
case SuccessfulOutcome__value_PR_UEContextSetupResponse:
{
DU_LOG("\nF1AP : UE ContextSetupResponse received");
+ f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
break;
}
default:
Code Review / o-du / l2.git / blobdiff