From: Harshita Lal Date: Thu, 7 Apr 2022 07:52:15 +0000 (+0000) Subject: Merge "[Epic-ID: ODUHIGH-405][Task-ID: ODUHIGH-435] Memory related Fixes in CU stub... X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=commitdiff_plain;h=38ebc92a011353b8b2d9401efa4173c79114fa1c;hp=84bdaa05da864fda46bbbdd184963787a827d0ab;p=o-du%2Fl2.git Merge "[Epic-ID: ODUHIGH-405][Task-ID: ODUHIGH-435] Memory related Fixes in CU stub with respect to Ue context release" --- diff --git a/src/5gnrmac/mac_msg_router.c b/src/5gnrmac/mac_msg_router.c index f3ef9b9c5..60be907c5 100755 --- a/src/5gnrmac/mac_msg_router.c +++ b/src/5gnrmac/mac_msg_router.c @@ -473,7 +473,7 @@ void callFlowRgActvTsk(Pst *pst) strcpy(message,"EVENT_MAC_SLICE_CFG_REQ"); break; case EVENT_MAC_SLICE_RECFG_REQ: - strcpy(message,"EVENT_MAC_SLICE_CFG_REQ"); + strcpy(message,"EVENT_MAC_SLICE_RECFG_REQ"); break; default: strcpy(message,"Invalid Event"); diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c index 992485b4e..fe18fec2e 100644 --- a/src/5gnrsch/sch.c +++ b/src/5gnrsch/sch.c @@ -1762,7 +1762,9 @@ uint8_t addSliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, S return RFAILED; } - memcpy(storeSliceCfg->listOfConfirguration[sliceIdx], cfgReq->listOfConfirguration[sliceIdx], sizeof(SchRrmPolicyOfSlice)); + memcpy(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &cfgReq->listOfConfirguration[sliceIdx]->snssai, sizeof(Snssai)); + memcpy(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, cfgReq->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, + sizeof(SchRrmPolicyRatio)); sliceIdx++; } } @@ -1898,7 +1900,8 @@ uint8_t modifySliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq { if(!memcmp(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &cfgReq->listOfConfirguration[cfgIdx]->snssai, sizeof(Snssai))) { - storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo = cfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo; + memcpy(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, cfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo, + sizeof(SchRrmPolicyRatio)); break; } } diff --git a/src/cm/du_app_mac_inf.c b/src/cm/du_app_mac_inf.c index 21f2dfaa3..e0e75c52f 100644 --- a/src/cm/du_app_mac_inf.c +++ b/src/cm/du_app_mac_inf.c @@ -1505,7 +1505,7 @@ uint8_t unpackDuMacSliceReCfgRsp(MacDuSliceReCfgRspFunc func, Pst *pst, Buffer * * * @details * - * Function : packDuMacSliceReCfgRsp + * Function : packMacSlotInd * * Functionality: * Pack and send Slot ind from MAC to DU APP diff --git a/src/cm/du_app_mac_inf.h b/src/cm/du_app_mac_inf.h index afd6ca672..16763d9b2 100644 --- a/src/cm/du_app_mac_inf.h +++ b/src/cm/du_app_mac_inf.h @@ -85,21 +85,6 @@ #define BSR_RETX_TIMER_SF_320 320 #define BSR_SR_DELAY_TMR_2560 2560 -#define GET_PAGING_CYCLE(enmValue, T) { \ - if (enmValue == 0) T = 32; \ - else if (enmValue == 1) T = 64; \ - else if (enmValue == 2) T = 128; \ - else if (enmValue == 3) T = 256; \ - else T = 0; \ -} - -#define GET_NUM_PAGING_OCC(enmValue, PO) { \ - if (enmValue == 0) PO = 4; \ - else if (enmValue == 1) PO = 2; \ - else if (enmValue == 2) PO = 1; \ - else PO = 0; \ -} - #define PAGING_SCHED_DELTA 4 typedef enum diff --git a/src/codec_utils/common/odu_common_codec.c b/src/codec_utils/common/odu_common_codec.c index b3ba6bc3e..a65aefc9e 100644 --- a/src/codec_utils/common/odu_common_codec.c +++ b/src/codec_utils/common/odu_common_codec.c @@ -48,16 +48,29 @@ int PrepFinalEncBuf(const void *buffer, size_t size, void *encodedBuf) * * ****************************************************************/ -uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, uint8_t val) +uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, uint64_t data) { - uint8_t tmp; + uint64_t tmp = 0; + uint8_t byteIdx = 0; + if(id->buf == NULLP) { + DU_LOG("\nERROR --> DU_APP : Buffer allocation is empty"); return RFAILED; } - - memset(id->buf, 0, byteSize-1); - id->buf[byteSize-1] = val; + memset(id->buf, 0, byteSize); + data = data << unusedBits; + + /*Now, seggregate the value into 'byteSize' number of Octets in sequence: + * 1. Pull out a byte of value (Starting from MSB) and put in the 0th Octet + * 2. Fill the buffer/String Octet one by one until LSB is reached*/ + for(byteIdx = 1; byteIdx <= byteSize; byteIdx++) + { + tmp = (uint64_t)0xFF; + tmp = (tmp << (8 * (byteSize - byteIdx))); + tmp = (data & tmp) >> (8 * (byteSize - byteIdx)); + id->buf[byteIdx - 1] = tmp; + } id->bits_unused = unusedBits; return ROK; } @@ -81,16 +94,16 @@ uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, ui uint8_t bitStringToInt(BIT_STRING_t *bitString, void *value) { uint16_t idx; - uint32_t *val = NULLP; + uint64_t *val = NULLP; if(bitString->buf == NULL || bitString->size <= 0) { - DU_LOG("\nDU_APP : Bit string is empty"); + DU_LOG("\nERROR --> DU_APP : Bit string is empty"); return RFAILED; } if(value) - val = (uint32_t *)value; + val = (uint64_t *)value; else return RFAILED; diff --git a/src/codec_utils/common/odu_common_codec.h b/src/codec_utils/common/odu_common_codec.h index 6edd2c28d..1c06c6565 100644 --- a/src/codec_utils/common/odu_common_codec.h +++ b/src/codec_utils/common/odu_common_codec.h @@ -28,7 +28,7 @@ char encBuf[ENC_BUF_MAX_LEN]; int encBufSize; int PrepFinalEncBuf(const void *buffer, size_t size, void *encodedBuf); -uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, uint8_t val); +uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, uint64_t val); uint8_t bitStringToInt(BIT_STRING_t *bitString, void *val); void fillTeIdString(uint8_t bufSize, uint32_t val, uint8_t *buf); void teIdStringToInt(uint8_t *buf, uint32_t *val); diff --git a/src/cu_stub/cu_f1ap_msg_hdl.c b/src/cu_stub/cu_f1ap_msg_hdl.c index 45d6859e6..151510428 100644 --- a/src/cu_stub/cu_f1ap_msg_hdl.c +++ b/src/cu_stub/cu_f1ap_msg_hdl.c @@ -127,6 +127,8 @@ #include "MeasConfigRrc.h" #include "AS-Config.h" #include "RRCReconfiguration-v1530-IEs.h" +#include "CNUEPagingIdentity.h" +#include "PagingCell-Item.h" #include "cu_stub_sctp.h" #include "cu_stub_egtp.h" @@ -2115,7 +2117,6 @@ uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId) uint8_t ret; uint8_t unused_bits = 4; uint8_t byteSize = 5; - uint8_t val = nrCellId << unused_bits; /* Allocate Buffer Memory */ nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t); @@ -2136,7 +2137,7 @@ uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId) { return RFAILED; } - fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, val); + fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId); return ROK; } @@ -2549,7 +2550,7 @@ uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , ui * RFAILED - failure * * ****************************************************************/ -uint8_t BuildULTnlInfo(TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress) +uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress) { uint8_t idx; uint8_t ulCnt; @@ -2628,7 +2629,7 @@ uint8_t BuildULTnlInfo(TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t 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++; + ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.egtpAssoc[duId-1].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]; @@ -2661,7 +2662,7 @@ uint8_t BuildULTnlInfo(TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t * RFAILED - failure * * ****************************************************************/ -uint8_t BuildDRBSetup(CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet) +uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet) { uint8_t idx = 0, extIeIdx = 0; uint8_t elementCnt = 0, drbCnt = 0; @@ -2758,10 +2759,10 @@ uint8_t BuildDRBSetup(CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet) /*ULUPTNLInformation To Be Setup List*/ if(ueCb->state != UE_HANDOVER_IN_PROGRESS) - BuildULTnlInforet = BuildULTnlInfo(&ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\ + BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\ FALSE); else - BuildULTnlInforet = BuildULTnlInfo(&ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\ + BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\ TRUE); if(BuildULTnlInforet != ROK) { @@ -7402,7 +7403,7 @@ void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList) * @return void * * ****************************************************************/ -uint8_t freeQuantityConfig(QuantityConfig_t *quantityCfg) +void freeQuantityConfig(QuantityConfig_t *quantityCfg) { uint8_t quanCfgIdx; QuantityConfigNR_t *quantityCfgNr; @@ -9034,7 +9035,7 @@ uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb, uint16_t rrcC 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(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List); + ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List); if(ret1 != ROK) { break; @@ -9181,7 +9182,7 @@ uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo) * RFAILED - failure * * ****************************************************************/ -uint8_t addDrbTunnels(uint8_t teId) +uint8_t addDrbTunnels(uint32_t duId, uint8_t teId) { uint8_t ret = ROK; EgtpTnlEvt tnlEvt; @@ -9194,7 +9195,7 @@ uint8_t addDrbTunnels(uint8_t teId) tnlEvt.action = EGTP_TNL_MGMT_ADD; tnlEvt.lclTeid = teId; tnlEvt.remTeid = teId; - ret = cuEgtpTnlMgmtReq(tnlEvt); + ret = cuEgtpTnlMgmtReq(duId, tnlEvt); if(ret != ROK) { DU_LOG("\nERROR --> EGTP : Tunnel management request failed for teId %x", teId); @@ -9217,7 +9218,7 @@ uint8_t addDrbTunnels(uint8_t teId) * RFAILED - failure * * ****************************************************************/ -uint8_t procDrbSetupList(DRBs_Setup_List_t *drbSetupList) +uint8_t procDrbSetupList(uint32_t duId, DRBs_Setup_List_t *drbSetupList) { uint8_t arrIdx = 0; uint32_t teId = 0; @@ -9234,7 +9235,7 @@ uint8_t procDrbSetupList(DRBs_Setup_List_t *drbSetupList) teId = extractTeId(&drbItemIe->value.choice.DRBs_Setup_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); } @@ -9285,7 +9286,7 @@ uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg) case ProtocolIE_ID_id_DRBs_Setup_List: { /* Adding Tunnels for successful DRB */ - procDrbSetupList(&ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List); + procDrbSetupList(duId, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List); break; } case ProtocolIE_ID_id_DUtoCURRCInformation: @@ -9621,7 +9622,7 @@ void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo) * RFAILED - failure * * ****************************************************************/ -uint8_t deleteEgtpTunnel(uint8_t *buf) +uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf) { uint32_t teId = 0; EgtpTnlEvt tnlEvt; @@ -9636,7 +9637,7 @@ uint8_t deleteEgtpTunnel(uint8_t *buf) 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); } @@ -9659,7 +9660,7 @@ uint8_t deleteEgtpTunnel(uint8_t *buf) * RFAILED - failure * * ****************************************************************/ -uint8_t BuildUlTnlInfoforSetupMod(uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, 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; @@ -9753,7 +9754,7 @@ uint8_t BuildUlTnlInfoforSetupMod(uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInf else { ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\ - gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++; + gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.egtpAssoc[duId-1].currTunnelId++; } ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0]; @@ -9864,7 +9865,7 @@ void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem) * * ****************************************************************/ -uint8_t FillDrbItemToSetupMod(CuUeCb *ueCb, 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; @@ -9944,7 +9945,7 @@ uint8_t FillDrbItemToSetupMod(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_It } /*ULUPTNLInformation To Be Setup List*/ - ret = BuildUlTnlInfoforSetupMod(ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \ + 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) { @@ -9977,13 +9978,13 @@ uint8_t FillDrbItemToSetupMod(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_It * * ****************************************************************/ -uint8_t FillDrbItemList(CuUeCb *ueCb, 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(ueCb, 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; @@ -10047,7 +10048,7 @@ void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet) * * ****************************************************************/ -uint8_t BuildDrbToBeSetupList(CuUeCb *ueCb, 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; @@ -10072,7 +10073,7 @@ uint8_t BuildDrbToBeSetupList(CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet) return RFAILED; } - ret = FillDrbItemList(ueCb, 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"); @@ -10099,7 +10100,7 @@ uint8_t BuildDrbToBeSetupList(CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet) * * ****************************************************************/ -uint8_t FillDrbToBeModItem(CuUeCb *ueCb, 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; @@ -10195,7 +10196,7 @@ uint8_t FillDrbToBeModItem(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_ }/* End of QoS */ /*ULUPTNLInformation To Be Setup List*/ - ret = BuildUlTnlInfoforSetupMod(ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &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) { @@ -10222,12 +10223,12 @@ uint8_t FillDrbToBeModItem(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_ * * ****************************************************************/ -uint8_t FillDrbToBeModItemList(CuUeCb *ueCb, 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(ueCb, 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; @@ -10253,7 +10254,7 @@ uint8_t FillDrbToBeModItemList(CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeMod * * ****************************************************************/ -uint8_t BuildDrbToBeModifiedList(CuUeCb *ueCb, 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; @@ -10277,7 +10278,7 @@ uint8_t BuildDrbToBeModifiedList(CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet) return RFAILED; } - ret = FillDrbToBeModItemList(ueCb, 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"); @@ -10581,7 +10582,7 @@ uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxt ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject; ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\ UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List; - ret = BuildDrbToBeSetupList(ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\ + ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\ value.choice.DRBs_ToBeSetupMod_List)); /* DRB to be modified list */ @@ -10590,7 +10591,7 @@ uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxt ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject; ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\ UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List; - ret = BuildDrbToBeModifiedList(ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\ + ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\ value.choice.DRBs_ToBeModified_List)); /* TODO: DRB to be release list */ @@ -11147,7 +11148,7 @@ uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList) * RFAILED - failure * * ****************************************************************/ -uint8_t procDrbSetupModList(CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList) +uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList) { uint8_t arrIdx = 0, drbIdx; uint32_t teId = 0; @@ -11176,7 +11177,7 @@ uint8_t procDrbSetupModList(CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList) 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); } @@ -11287,7 +11288,7 @@ uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg) case ProtocolIE_ID_id_DRBs_SetupMod_List: { /* Adding Tunnels for successful DRB */ - procDrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List); + procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List); break; } @@ -11488,6 +11489,362 @@ void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg) } } +/******************************************************************* + * + * @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 ; ieIdxprotocolIEs.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 ; ieIdxprotocolIEs.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 diff --git a/src/cu_stub/cu_f1ap_msg_hdl.h b/src/cu_stub/cu_f1ap_msg_hdl.h index 0ebc88d5f..51f8d9ae5 100644 --- a/src/cu_stub/cu_f1ap_msg_hdl.h +++ b/src/cu_stub/cu_f1ap_msg_hdl.h @@ -179,6 +179,7 @@ void F1APMsgHdlr(uint32_t *destDuId, Buffer *mBuf); uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *ueCb, UeCtxtModAction action); uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId); uint8_t BuildAndSendF1ResetReq(); +uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId); /********************************************************************** End of file diff --git a/src/cu_stub/cu_stub.c b/src/cu_stub/cu_stub.c index 31515a4c6..17c18ad58 100644 --- a/src/cu_stub/cu_stub.c +++ b/src/cu_stub/cu_stub.c @@ -133,7 +133,7 @@ uint8_t tst() void readCuCfg() { - uint8_t *numDu; + uint8_t numDu; uint32_t ipv4_du, ipv4_cu; DU_LOG("\nDEBUG --> CU_STUB : Reading CU configurations"); @@ -162,25 +162,42 @@ void readCuCfg() cuCb.cuCfgParams.sctpParams.numDu = 1; #else cuCb.cuCfgParams.sctpParams.numDu = 0; - numDu = &cuCb.cuCfgParams.sctpParams.numDu; - while(*numDu < MAX_DU_SUPPORTED) + cuCb.cuCfgParams.egtpParams.numDu = 0; + numDu = 0; + while(numDu < MAX_DU_SUPPORTED) { /* DU IP Address and Port*/ memset(&ipv4_du, 0, sizeof(uint32_t)); - cmInetAddr((S8*)DU_IP_V4_ADDR[*numDu], &ipv4_du); - cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].duIpAddr.ipV4Addr = ipv4_du; - cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].duIpAddr.ipV6Pres = false; - cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].duPort = DU_SCTP_PORT[*numDu]; + cmInetAddr((S8*)DU_IP_V4_ADDR[numDu], &ipv4_du); + cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].duIpAddr.ipV4Addr = ipv4_du; + cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].duIpAddr.ipV6Pres = false; + cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].duPort = DU_SCTP_PORT[numDu]; /* CU IP Address and Port*/ memset(&ipv4_du, 0, sizeof(uint32_t)); cmInetAddr((S8*)CU_IP_V4_ADDR, &ipv4_cu); - cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].cuIpAddr.ipV4Addr = ipv4_cu; - cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].cuIpAddr.ipV6Pres = false; - cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].cuPort = CU_SCTP_PORT_TO_DU[*numDu]; - (*numDu)++; + cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].cuIpAddr.ipV4Addr = ipv4_cu; + cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].cuIpAddr.ipV6Pres = false; + cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].cuPort = CU_SCTP_PORT_TO_DU[numDu]; + + /* EGTP Parameters */ + memset(&ipv4_du, 0, sizeof(uint32_t)); + cmInetAddr((S8*)DU_IP_V4_ADDR[numDu], &ipv4_du); + cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].localIp.ipV4Pres = TRUE; + cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].localIp.ipV4Addr = ipv4_cu; + cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].localPort = CU_EGTP_PORT[numDu]; + cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].destIp.ipV4Pres = TRUE; + cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].destIp.ipV4Addr = ipv4_du; + cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].destPort = DU_EGTP_PORT[numDu]; + cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].minTunnelId = MIN_TEID; + cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].currTunnelId = cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].minTunnelId; + cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].maxTunnelId = MAX_TEID; + + (numDu)++; } + cuCb.cuCfgParams.egtpParams.numDu = numDu; + cuCb.cuCfgParams.sctpParams.numDu = numDu; #endif /*PLMN*/ @@ -196,16 +213,6 @@ void readCuCfg() cuCb.cuCfgParams.rrcVersion.extRrcVer = EXT_RRC_VER; - /* EGTP Parameters */ - cuCb.cuCfgParams.egtpParams.localIp.ipV4Pres = TRUE; - cuCb.cuCfgParams.egtpParams.localIp.ipV4Addr = ipv4_cu; - cuCb.cuCfgParams.egtpParams.localPort = CU_EGTP_PORT; - cuCb.cuCfgParams.egtpParams.destIp.ipV4Pres = TRUE; - cuCb.cuCfgParams.egtpParams.destIp.ipV4Addr = ipv4_du; - cuCb.cuCfgParams.egtpParams.destPort = DU_EGTP_PORT; - cuCb.cuCfgParams.egtpParams.minTunnelId = MIN_TEID; - cuCb.cuCfgParams.egtpParams.currTunnelId = cuCb.cuCfgParams.egtpParams.minTunnelId; - cuCb.cuCfgParams.egtpParams.maxTunnelId = MAX_TEID; } /* End of readCuCfg */ @@ -276,7 +283,7 @@ void *cuConsoleHandler(void *args) * NUM_TUNNEL_TO_PUMP_DATA = 9, NUM_DL_PACKETS = 1. * totalDataPacket = totalNumOfTestFlow * NUM_TUNNEL_TO_PUMP_DATA * NUM_DL_PACKETS * totalDataPacket = [500*9*1] */ - int32_t totalNumOfTestFlow = 500; + int32_t totalNumOfTestFlow = 5; while(true) { @@ -285,11 +292,11 @@ void *cuConsoleHandler(void *args) if(ch == 'd') { - /* Change #if 0 to #if 1 to take input from user */ + /* Change #if 0 to #if 1 to take input from user */ #if 0 DU_LOG("\n EGTP --> : Enter TEID id(1..10) where DL Data to be sent\n"); scanf("%d",&teId); - + if(teId > MAX_TEID || teId < MIN_TEID) { DU_LOG("\nERROR --> EGTP : TEID(%x) OUT Of Range",teId); @@ -351,6 +358,23 @@ void *cuConsoleHandler(void *args) initiateInterDuHandover(sourceDuId, targetDuId, ueId); } + /* Start Idle mode paging when 'p' is received from console input */ + else if(ch == 'p') + { + uint64_t sTmsi = 0; + uint8_t duId = 0; + + DU_LOG("\nEnter DU ID on which this UE to be pagged"); + scanf("%d", &duId); + DU_LOG("\nEnter 5g-S-TMSI"); + scanf("%lu", &sTmsi); + + if(BuildAndSendPagingMsg(sTmsi, duId) != ROK) + { + DU_LOG("\nERROR --> EGTP: Failed to build and send paging message for 5gsTmsi[%lu]\n", sTmsi); + } + continue; + } } } /********************************************************************** diff --git a/src/cu_stub/cu_stub.h b/src/cu_stub/cu_stub.h index 34cef6f77..ed0adced7 100644 --- a/src/cu_stub/cu_stub.h +++ b/src/cu_stub/cu_stub.h @@ -33,8 +33,8 @@ #define CU_SCTP_PORT_TO_DU (int[]){38472, 38473} #endif -#define DU_EGTP_PORT 39001 -#define CU_EGTP_PORT 39002 +#define DU_EGTP_PORT (int[]){39001, 39002} +#define CU_EGTP_PORT (int[]){39003, 39004} #define RRC_VER 0 #define EXT_RRC_VER 5 #define PLMN_MCC0 3 @@ -122,7 +122,7 @@ typedef struct cuCfgParams char cuName[CU_DU_NAME_LEN_MAX]; CuSctpParams sctpParams; Plmn plmn; - EgtpParams egtpParams; + CuEgtpParams egtpParams; RrcVersion rrcVersion; }CuCfgParams; diff --git a/src/cu_stub/cu_stub_egtp.c b/src/cu_stub/cu_stub_egtp.c index 8657cb2cd..ba5136990 100644 --- a/src/cu_stub/cu_stub_egtp.c +++ b/src/cu_stub/cu_stub_egtp.c @@ -84,7 +84,8 @@ S16 egtpActvInit() uint8_t egtpInitReq() { uint8_t ret = ROK; - + + egtpCb.egtpCfg = cuCb.cuCfgParams.egtpParams; ret = cuEgtpCfgReq(); if(ret != ROK) { @@ -118,30 +119,35 @@ uint8_t egtpInitReq() * ***********************************************************************/ S16 cuEgtpCfgReq() { - uint8_t ret; - - memcpy(&egtpCb.egtpCfg, &cuCb.cuCfgParams.egtpParams, sizeof(EgtpParams)); - - egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr); - egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT; + uint8_t ret, destIdx =0; + + memcpy(&egtpCb.egtpCfg, &cuCb.cuCfgParams.egtpParams, sizeof(CuEgtpParams)); + + for(destIdx=0; destIdx < egtpCb.egtpCfg.numDu; destIdx++) + { + egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[destIdx].localIp.ipV4Addr); + egtpCb.recvTptSrvr.addr.port = EGTP_RECVR_PORT; - egtpCb.dstCb.dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr); - egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort; - egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr); - egtpCb.dstCb.sendTptSrvr.addr.port = egtpCb.egtpCfg.localPort; - egtpCb.dstCb.numTunn = 0; + egtpCb.dstCb[destIdx].duId = destIdx+1; + egtpCb.dstCb[destIdx].dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[destIdx].destIp.ipV4Addr); + egtpCb.dstCb[destIdx].dstPort = egtpCb.egtpCfg.egtpAssoc[destIdx].destPort; + egtpCb.dstCb[destIdx].sendTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[destIdx].localIp.ipV4Addr); + egtpCb.dstCb[destIdx].sendTptSrvr.addr.port = egtpCb.egtpCfg.egtpAssoc[destIdx].localPort; + egtpCb.dstCb[destIdx].numTunn = 0; - ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_UINT32_MOD, CU_APP_MEM_REG, CU_POOL); + ret = cmHashListInit(&(egtpCb.dstCb[destIdx].teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_UINT32_MOD, CU_APP_MEM_REG, CU_POOL); - if(ret != ROK) - { - DU_LOG("\nERROR --> EGTP : TeId hash list initialization failed"); - return RFAILED; - } - else - { - DU_LOG("\nINFO --> EGTP : Configuration successful"); + if(ret != ROK) + { + DU_LOG("\nERROR --> EGTP : TeId hash list initialization failed"); + return RFAILED; + } + else + { + DU_LOG("\nINFO --> EGTP : Configuration successful"); + } } + egtpCb.numDu = egtpCb.egtpCfg.numDu; return ROK; } /* cuEgtpCfgReq */ @@ -166,10 +172,10 @@ S16 cuEgtpCfgReq() S16 cuEgtpSrvOpenReq(Pst *pst) { - uint8_t ret; + uint8_t ret, destIdx; DU_LOG("\nINFO --> EGTP : Received open server request"); - + sockType = CM_INET_DGRAM; if((ret = (cmInetSocket(sockType, &(egtpCb.recvTptSrvr.sockFd), protType))) != ROK) { @@ -183,24 +189,27 @@ S16 cuEgtpSrvOpenReq(Pst *pst) DU_LOG("\nERROR --> EGTP : Failed to bind socket"); return RFAILED; } + + for(destIdx=0; destIdx < egtpCb.egtpCfg.numDu; destIdx++) + { + if(ret = (cmInetSocket(sockType, &(egtpCb.dstCb[destIdx].sendTptSrvr.sockFd), protType)) != ROK) + { + DU_LOG("\nERROR --> EGTP : Failed to open UDP socket"); + return RFAILED; + } - if(ret = (cmInetSocket(sockType, &(egtpCb.dstCb.sendTptSrvr.sockFd), protType)) != ROK) - { - DU_LOG("\nERROR --> EGTP : Failed to open UDP socket"); - return RFAILED; - } - - ret = cmInetBind(&(egtpCb.dstCb.sendTptSrvr.sockFd), &(egtpCb.dstCb.sendTptSrvr.addr)); - if(ret != ROK) - { - DU_LOG("\nERROR --> EGTP : Failed to bind socket"); - return RFAILED; - } - - /* TODO: set socket options */ + ret = cmInetBind(&(egtpCb.dstCb[destIdx].sendTptSrvr.sockFd), &(egtpCb.dstCb[destIdx].sendTptSrvr.addr)); + if(ret != ROK) + { + DU_LOG("\nERROR --> EGTP : Failed to bind socket"); + return RFAILED; + } - DU_LOG("\nINFO --> EGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd,\ - egtpCb.dstCb.sendTptSrvr.sockFd.fd); + /* TODO: set socket options */ + + DU_LOG("\nINFO --> EGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd,\ + egtpCb.dstCb[destIdx].sendTptSrvr.sockFd.fd); + } return ROK; } /* cuEgtpSrvOpenReq */ @@ -222,7 +231,7 @@ S16 cuEgtpSrvOpenReq(Pst *pst) * * ***************************************************************************/ -S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt) +S16 cuEgtpTnlMgmtReq(uint32_t duId, EgtpTnlEvt tnlEvt) { S8 ret; @@ -231,17 +240,17 @@ S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt) { case EGTP_TNL_MGMT_ADD: { - ret = cuEgtpTnlAdd(tnlEvt); + ret = cuEgtpTnlAdd(duId, tnlEvt); break; } case EGTP_TNL_MGMT_MOD: { - ret = cuEgtpTnlMod(tnlEvt); + ret = cuEgtpTnlMod(duId, tnlEvt); break; } case EGTP_TNL_MGMT_DEL: { - ret = cuEgtpTnlDel(tnlEvt); + ret = cuEgtpTnlDel(duId, tnlEvt); break; } default: @@ -269,7 +278,7 @@ S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt) * RFAILED - failure * * ***************************************************************************/ -S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt) +S16 cuEgtpTnlAdd(uint32_t duId, EgtpTnlEvt tnlEvt) { S16 ret; EgtpTeIdCb *teidCb; @@ -291,14 +300,14 @@ S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt) teidCb->teId = tnlEvt.lclTeid; teidCb->remTeId = tnlEvt.remTeid; - ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t)); + ret = cmHashListInsert(&(egtpCb.dstCb[duId-1].teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t)); if(ret != ROK) { DU_LOG("\nERROR --> EGTP : Failed to insert in hash list"); CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb)); return RFAILED; } - egtpCb.dstCb.numTunn++; + egtpCb.dstCb[duId-1].numTunn++; /* Encoding pre-defined header */ memset(&preDefHdr, 0, sizeof(EgtpMsgHdr)); @@ -332,7 +341,7 @@ S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt) * RFAILED - failure * * ***************************************************************************/ -S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt) +S16 cuEgtpTnlMod(uint32_t duId, EgtpTnlEvt tnlEvt) { #if 0 S16 ret; @@ -340,7 +349,7 @@ S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt) DU_LOG("\nDEBUG --> CU_STUB : Tunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid); - cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb); + cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb); if(teidCb == NULLP) { DU_LOG("\nDEBUG --> CU_STUBTunnel id not found"); @@ -368,22 +377,22 @@ S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt) * RFAILED - failure * * ***************************************************************************/ -S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt) +S16 cuEgtpTnlDel(uint32_t duId, EgtpTnlEvt tnlEvt) { EgtpTeIdCb *teidCb = NULLP; DU_LOG("\nDEBUG --> EGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid); - cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb); + cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb); if(teidCb == NULLP) { DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid); return RFAILED; } - cmHashListDelete(&(egtpCb.dstCb.teIdLst), (PTR)teidCb); + cmHashListDelete(&(egtpCb.dstCb[duId-1].teIdLst), (PTR)teidCb); CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb)); - egtpCb.dstCb.numTunn--; + egtpCb.dstCb[duId-1].numTunn--; return ROK; } /* cuEgtpTnlDel */ @@ -499,6 +508,22 @@ S16 cuEgtpEncodeHdr(uint8_t *preEncodedHdr, EgtpMsgHdr *preDefHdr, uint8_t *hdrI } /* egtpEncodeHdr */ +/******************************************************************* + * + * @brief This handles the any EGTP received message + * + * @details + * + * Function : cuEgtpHdlRecvMsg + * + * Functionality: + * This handles the any EGTP received message + * + * @params[in] Message Buffer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ S16 cuEgtpHdlRecvMsg(Buffer *mBuf) { /*Decoding of EGTP message header */ @@ -510,6 +535,22 @@ S16 cuEgtpHdlRecvMsg(Buffer *mBuf) } +/******************************************************************* + * + * @brief Decodes message header + * + * @details + * + * Function : cuEgtpDecodeHdr + * + * Functionality: + * Decodes EGTP message haeder + * + * @params[in] Message Buffer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ S16 cuEgtpDecodeHdr(Buffer *mBuf) { EgtpMsg egtpMsg; @@ -627,9 +668,28 @@ S16 cuEgtpDecodeHdr(Buffer *mBuf) } /* End of cuEgtpDecodeHdr */ +/******************************************************************* + * + * @brief This function is responsible to build application message, encode EGTP + * header to it and send to DU over tunnel (teId) + * + * @details + * + * Function : cuEgtpDatReq + * + * Functionality: + * function is responsible to build application message, encode EGTP + * header to it and send to DU over tunnel (teId) + * + * @params[in] uint8_t teId + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ uint16_t cuEgtpDatReq(uint8_t teId) { - uint8_t ret = ROK, cnt = 0; + uint8_t ret = ROK, cnt = 0, duId =0; EgtpMsg egtpMsg; egtpMsg.msgHdr.teId = teId; @@ -639,29 +699,48 @@ uint16_t cuEgtpDatReq(uint8_t teId) DU_LOG("\nERROR --> EGTP : DRB not created"); return RFAILED ; } - /* Build Application message that is supposed to come from app to egtp */ - ret = BuildAppMsg(&egtpMsg); - if(ret != ROK) + for(duId = 1; duId<=egtpCb.numDu; duId++) { - DU_LOG("\nERROR --> EGTP : Failed to build App Msg"); - return RFAILED; - } + /* Build Application message that is supposed to come from app to egtp */ + ret = BuildAppMsg(duId, &egtpMsg); + if(ret != ROK) + { + DU_LOG("\nERROR --> EGTP : Failed to build App Msg"); + return RFAILED; + } - /* Encode EGTP header to build final EGTP message */ - ret = BuildEgtpMsg(&egtpMsg); - if(ret != ROK) - { - DU_LOG("\nERROR --> EGTP : Failed to build EGTP Msg"); - return RFAILED; + /* Encode EGTP header to build final EGTP message */ + ret = BuildEgtpMsg(duId, &egtpMsg); + if(ret != ROK) + { + DU_LOG("\nERROR --> EGTP : Failed to build EGTP Msg"); + return RFAILED; + } + cuEgtpSendMsg(duId, egtpMsg.msg); + ODU_PUT_MSG_BUF(egtpMsg.msg); } - cuEgtpSendMsg(egtpMsg.msg); - ODU_PUT_MSG_BUF(egtpMsg.msg); - return ROK; } -S16 BuildAppMsg(EgtpMsg *egtpMsg) +/******************************************************************* + * + * @brief Builds application message to be sent to DU in DL path + * + * @details + * + * Function : BuildAppMsg + * + * Functionality: + * Builds application message to be sent to DU in DL path + * + * @params[in] uint32_t duId,EGTP message + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +S16 BuildAppMsg(uint32_t duId, EgtpMsg *egtpMsg) { char data[1215] = "In telecommunications, 5G is the fifth generation technology standard for broadband cellular" " networks, which cellular phone companies began deploying worldwide in 2019, and is the planned successor to the 4G " @@ -705,8 +784,8 @@ S16 BuildAppMsg(EgtpMsg *egtpMsg) ipv4Hdr.length = CM_IPV4_HDRLEN + mLen; ipv4Hdr.hdrVer = 0x45; ipv4Hdr.proto = 1; - ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr); - ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr); + ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[duId-1].localIp.ipV4Addr); + ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[duId-1].destIp.ipV4Addr); /* Packing IPv4 header into buffer */ S16 ret, cnt, idx; @@ -780,7 +859,24 @@ S16 BuildAppMsg(EgtpMsg *egtpMsg) return ret; } -S16 BuildEgtpMsg(EgtpMsg *egtpMsg) +/******************************************************************* + * + * @brief Encodes EGTP header to application message to send to DU + * + * @details + * + * Function : BuildEgtpMsg + * + * Functionality: + * Encodes EGTP header to application message to send to DU + * + * @params[in] uint32_t duId,EGTP message + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +S16 BuildEgtpMsg(uint32_t duId, EgtpMsg *egtpMsg) { EgtpTeIdCb *teidCb = NULLP; MsgLen tPduSize; @@ -788,7 +884,7 @@ S16 BuildEgtpMsg(EgtpMsg *egtpMsg) uint32_t msgLen; EgtpMsgHdr *msgHdr; - cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(egtpMsg->msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb); + cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(egtpMsg->msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb); if(teidCb == NULLP) { DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", egtpMsg->msgHdr.teId); @@ -851,7 +947,24 @@ S16 BuildEgtpMsg(EgtpMsg *egtpMsg) return ROK; } -S16 cuEgtpSendMsg(Buffer *mBuf) +/******************************************************************* + * + * @brief Send the egtp message to the destination DU + * + * @details + * + * Function : cuEgtpSendMsg + * + * Functionality: + * Send the egtp message to the destination DU + * + * @params[in] uint32_t duId + * Message Buffer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +S16 cuEgtpSendMsg(uint32_t duId, Buffer *mBuf) { S16 ret; MsgLen txLen; @@ -861,10 +974,10 @@ S16 cuEgtpSendMsg(Buffer *mBuf) info.region = CU_APP_MEM_REG; info.pool = CU_POOL; - dstAddr.port = EGTP_DFLT_PORT; - dstAddr.address = egtpCb.dstCb.dstIp; + dstAddr.port = EGTP_RECVR_PORT; + dstAddr.address = egtpCb.dstCb[duId-1].dstIp; - ret = cmInetSendMsg(&(egtpCb.dstCb.sendTptSrvr.sockFd), &dstAddr, &info, mBuf, &txLen, CM_INET_NO_FLAG); + ret = cmInetSendMsg(&(egtpCb.dstCb[duId-1].sendTptSrvr.sockFd), &dstAddr, &info, mBuf, &txLen, CM_INET_NO_FLAG); if(ret != ROK && ret != RWOULDBLOCK) { DU_LOG("\nERROR --> EGTP : Message send failure"); diff --git a/src/cu_stub/cu_stub_egtp.h b/src/cu_stub/cu_stub_egtp.h index 0ca75fc20..8510c9ca4 100644 --- a/src/cu_stub/cu_stub_egtp.h +++ b/src/cu_stub/cu_stub_egtp.h @@ -21,7 +21,7 @@ #ifndef __CU_STUB_EGTP_H__ #define __CU_STUB_EGTP_H__ -#define EGTP_DFLT_PORT 2152 +#define EGTP_RECVR_PORT 2152 /* As per the spec 29.281, the registered port number for GTP-U is 2152 */ #define EGTP_TNL_MGMT_ADD 1 #define EGTP_TNL_MGMT_MOD 2 #define EGTP_TNL_MGMT_DEL 3 @@ -111,6 +111,7 @@ typedef struct EgtpTeIdCb typedef struct egtpDstCb { + uint32_t duId; CmInetIpAddr dstIp; /* destination IP */ uint16_t dstPort; /* Remote port that sends data */ EgtpTptSrvr sendTptSrvr; /* Transport server for sending UDP msg to */ @@ -118,7 +119,7 @@ typedef struct egtpDstCb CmHashListCp teIdLst; /* Tunnel Id list for this destination */ }EgtpDstCb; -typedef struct egtpParams +typedef struct egtpAssoc { SctpIpAddr localIp; uint16_t localPort; @@ -127,13 +128,20 @@ typedef struct egtpParams uint32_t currTunnelId; uint32_t minTunnelId; uint32_t maxTunnelId; -}EgtpParams; +}EgtpAssoc; + +typedef struct cuEgtpParams +{ + uint8_t numDu; + EgtpAssoc egtpAssoc[MAX_DU_SUPPORTED]; +}CuEgtpParams; typedef struct egtpGlobalCb { - EgtpParams egtpCfg; /* EGTP configuration */ + CuEgtpParams egtpCfg; /* EGTP configuration */ EgtpTptSrvr recvTptSrvr; /* Transport server for receiving UDP msg */ - EgtpDstCb dstCb; /* Destination endpoint */ + uint8_t numDu; + EgtpDstCb dstCb[MAX_DU_SUPPORTED]; /* Destination endpoint */ uint8_t gCntPdu[MAX_TEID+1]; /* Maintaining PDU count for each bearer */ }EgtpGlobalCb; EgtpGlobalCb egtpCb; /* EGTP global control block */ @@ -141,16 +149,16 @@ EgtpGlobalCb egtpCb; /* EGTP global control block */ S16 egtpActvInit(); S16 cuEgtpCfgReq(); S16 cuEgtpSrvOpenReq(); -S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt); -S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt); -S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt); -S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt); +S16 cuEgtpTnlMgmtReq(uint32_t duId,EgtpTnlEvt tnlEvt); +S16 cuEgtpTnlAdd(uint32_t duId, EgtpTnlEvt tnlEvt); +S16 cuEgtpTnlMod(uint32_t duId,EgtpTnlEvt tnlEvt); +S16 cuEgtpTnlDel(uint32_t duId,EgtpTnlEvt tnlEvt); S16 cuEgtpEncodeHdr(uint8_t *preEncodedHdr, EgtpMsgHdr *preDefHdr, uint8_t *hdrIdx); S16 cuEgtpHdlRecvMsg(Buffer *mBuf); uint16_t cuEgtpDatReq(uint8_t teId); -S16 BuildAppMsg(EgtpMsg *egtpMsg); -S16 BuildEgtpMsg(EgtpMsg *egtpMsg); -S16 cuEgtpSendMsg(Buffer *mBuf); +S16 BuildAppMsg(uint32_t duId, EgtpMsg *egtpMsg); +S16 BuildEgtpMsg(uint32_t duId, EgtpMsg *egtpMsg); +S16 cuEgtpSendMsg(uint32_t duId, Buffer *mBuf); S16 cuEgtpDecodeHdr(Buffer *mBuf); #endif diff --git a/src/cu_stub/cu_stub_sctp.c b/src/cu_stub/cu_stub_sctp.c index aa8626ea6..c74290a22 100644 --- a/src/cu_stub/cu_stub_sctp.c +++ b/src/cu_stub/cu_stub_sctp.c @@ -420,8 +420,6 @@ uint8_t sctpSockPoll() memset(&f1PollParams, 0, sizeof(sctpSockPollParams)); - egtpFromAddr.port = egtpCb.dstCb.dstPort; - egtpFromAddr.address = egtpCb.dstCb.dstIp; /* All sockets are non-blocking */ timeout = 0; @@ -443,15 +441,21 @@ uint8_t sctpSockPoll() } /* Receiving EGTP data */ - egtpBufLen = -1; - ret = cmInetRecvMsg(&(egtpCb.recvTptSrvr.sockFd), &egtpFromAddr, &memInfo, &egtpBuf, &egtpBufLen, CM_INET_NO_FLAG); - if(ret == ROK && egtpBuf != NULLP) + for(destIdx = 0; destIdx < egtpCb.numDu; destIdx++) { - DU_LOG("\nINFO --> EGTP : Received UL Message [%ld]\n", numMsgRcvd+1); - numMsgRcvd++; - //ODU_PRINT_MSG(egtpBuf, 0 ,0); - cuEgtpHdlRecvMsg(egtpBuf); + + egtpFromAddr.port = egtpCb.dstCb[destIdx].dstPort; + egtpFromAddr.address = egtpCb.dstCb[destIdx].dstIp; + egtpBufLen = -1; + ret = cmInetRecvMsg(&(egtpCb.recvTptSrvr.sockFd), &egtpFromAddr, &memInfo, &egtpBuf, &egtpBufLen, CM_INET_NO_FLAG); + if(ret == ROK && egtpBuf != NULLP) + { + DU_LOG("\nINFO --> EGTP : Received UL Message [%ld] from DUid %d\n", numMsgRcvd+1, egtpCb.dstCb[destIdx].duId); + numMsgRcvd++; + //ODU_PRINT_MSG(egtpBuf, 0 ,0); + cuEgtpHdlRecvMsg(egtpBuf); + } } }; return (ret); diff --git a/src/cu_stub/cu_stub_sctp.h b/src/cu_stub/cu_stub_sctp.h index 2c0a9b7b1..ed09e2769 100644 --- a/src/cu_stub/cu_stub_sctp.h +++ b/src/cu_stub/cu_stub_sctp.h @@ -72,7 +72,7 @@ typedef struct sctpAssocInfo uint16_t cuPort; }SctpAssocInfo; -typedef struct CuSctpParams +typedef struct cuSctpParams { uint8_t numDu; SctpAssocInfo sctpAssoc[MAX_DU_SUPPORTED]; diff --git a/src/du_app/du_cell_mgr.c b/src/du_app/du_cell_mgr.c index 635cda773..d40755b36 100644 --- a/src/du_app/du_cell_mgr.c +++ b/src/du_app/du_cell_mgr.c @@ -30,6 +30,7 @@ #include "du_mgr.h" #include "du_utils.h" #include "du_cell_mgr.h" +#include "PCCH-Config.h" #ifdef O1_ENABLE @@ -226,26 +227,6 @@ uint8_t duHandleCellUpInd(Pst *pst, OduCellId *cellId) { DuCellCb *cellCb = NULLP; -#ifndef O1_ENABLE - - /*Note: Static Configuration, when O1 is not configuring the RRM policy*/ - RrmPolicy *rrmPolicy; - DU_ALLOC(rrmPolicy, sizeof(RrmPolicy)); - rrmPolicy->rsrcType = RSRC_PRB; - rrmPolicy->numMemberList = 1; - DU_ALLOC(rrmPolicy->memberList, sizeof(PolicyMemberList *)); - DU_ALLOC(rrmPolicy->memberList[0], sizeof(PolicyMemberList)); - - memset(&rrmPolicy->memberList[0]->plmn, 0, sizeof(Plmn)); - rrmPolicy->memberList[0]->snssai.sst = 1; - rrmPolicy->memberList[0]->snssai.sd[0] = 2; - rrmPolicy->memberList[0]->snssai.sd[1] = 3; - rrmPolicy->memberList[0]->snssai.sd[2] = 4; - rrmPolicy->policyMinRatio = 30; - rrmPolicy->policyMaxRatio = 90; - rrmPolicy->policyDedicatedRatio = 10; -#endif - if(cellId->cellId <=0 || cellId->cellId > MAX_NUM_CELL) { DU_LOG("\nERROR --> DU APP : Invalid Cell Id %d in duHandleCellUpInd()", cellId->cellId); @@ -261,14 +242,12 @@ uint8_t duHandleCellUpInd(Pst *pst, OduCellId *cellId) cellCb->cellStatus = ACTIVATED; gCellStatus = CELL_UP; -#ifdef O1_ENABLE if(duCfgParam.tempSliceCfg.rrmPolicy) BuildAndSendSliceConfigReq(duCfgParam.tempSliceCfg.rrmPolicy, duCfgParam.tempSliceCfg.totalRrmPolicy, duCfgParam.tempSliceCfg.totalSliceCount); +#ifdef O1_ENABLE DU_LOG("\nINFO --> DU APP : Raise cell UP alarm for cell id=%d", cellId->cellId); raiseCellAlrm(CELL_UP_ALARM_ID, cellId->cellId); setCellOpState(cellId->cellId, ENABLED, ACTIVE); -#else - BuildAndSendSliceConfigReq(&rrmPolicy,1, rrmPolicy->numMemberList); #endif } @@ -442,6 +421,153 @@ uint8_t duSendCellDeletReq(uint16_t cellId) return ROK; } +/******************************************************************* + * @brief fill paging information of a UE belongs to a particular cell + * + * @details + * + * Function : FillPagingInfoInCellCb + * + * Functionality: fill paging information of a UE in DuCellCb + * + * @params[in] DuCellCb* cellCb, uint8_t ueId, + * DuPagingMsg rcvdF1apPagingParam + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t FillPagingInfoInCellCb(DuCellCb* cellCb, DuPagingMsg *rcvdF1apPagingParam) +{ + uint8_t ns = 0; + uint16_t T=0, N=0, pagingFrame = 0, n = 0; + uint16_t currentSfn = 0, sfn = 0, newSfn = 0; + PcchCfg duPcchCfg; + + DU_LOG("\nINFO --> DU APP : Start filling paging parameters in DuCellCb"); + if(cellCb) + { + /* calculate paging frame and paging offset */ + duPcchCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg; + rcvdF1apPagingParam->pagingFrameOffset = duPcchCfg.pageFrameOffset; + ns = duPcchCfg.ns; + + /* + * Fill the Value of T (DRX cycle of the UE) + * T = min(UE Specific DRX value allocated by upper layers, default DRX + * broadcast in System Information) */ + if((rcvdF1apPagingParam->pagingDrxPres) && (duPcchCfg.dfltPagingCycle > rcvdF1apPagingParam->pagingDrx)) + { + T = rcvdF1apPagingParam->pagingDrx; + } + else + { + T = duPcchCfg.dfltPagingCycle; + } + rcvdF1apPagingParam->T = T; + + /* N= number of total paging frames in T */ + + switch(duPcchCfg.nAndPagingFrmOffsetType) + { + case PCCH_Config__nAndPagingFrameOffset_PR_oneT: + N = T; + break; + case PCCH_Config__nAndPagingFrameOffset_PR_halfT: + N = T/2; + break; + case PCCH_Config__nAndPagingFrameOffset_PR_quarterT: + N = T/4; + break; + case PCCH_Config__nAndPagingFrameOffset_PR_oneEighthT: + N = T/8; + break; + case PCCH_Config__nAndPagingFrameOffset_PR_oneSixteenthT: + N = T/16; + break; + default: + N = T; + break; + } + + /* calculate the Value of pagingFrame */ + /*Refer: 38.304 Sec 7.1: (SFN + PF_offset) mod T = (T div N)*(UE_ID mod N)*/ + //RHS of above formula + pagingFrame = (T / N) * ((rcvdF1apPagingParam->ueId) % N); + + //LHS of above formula + if(pagingFrame) + { + pagingFrame = (pagingFrame - rcvdF1apPagingParam->pagingFrameOffset)%T; + } + else /*Paging Frame = 0 so thus PF will be calculated on Paging Cycle*/ + { + pagingFrame = (T - rcvdF1apPagingParam->pagingFrameOffset)%T; + } + + /*Paging Frame(SFN for Paging) has to be determined from current SFN. */ + /*For eg: If T =128, PF(Calculated above) = 20; SFN can be 20,148,276,... + * If currSFN is running as 200 then (newSFN % T) == (T/N)*(UE_ID%N) + *Thus SFN at which paging has to be sent needs to be delayed and newSFN = 276*/ + + currentSfn = cellCb->currSlotInfo.sfn; + + /*Multiplication Factor(x) to find the next best SFN to process paging*/ + + /*Below calculation will determine in which nth cycle of T (DRX cycle),new PF + * may fall(Delayed one)*/ + if(currentSfn > pagingFrame) + { + n = ((currentSfn - pagingFrame) / T) + 1; + } + else + { + n = ((pagingFrame - currentSfn) / T) + 1; + } + + newSfn = pagingFrame + T * n; + + /*When pagingFrame is future from currSFN then pagingFrame will be used + * else pagingFrame is delayed thus newSFN will be used.*/ + if(currentSfn <= pagingFrame) + { + if(pagingFrame > currentSfn + PAGING_SCHED_DELTA) + { + sfn = pagingFrame; + } + else + { + sfn = newSfn; + } + } + else + { + + if(newSfn > currentSfn + PAGING_SCHED_DELTA) + { + sfn = newSfn; + } + else /*If newSFN is near to currSFN then delay it more by T*/ + { + newSfn = newSfn + T; + sfn = newSfn; + } + } + rcvdF1apPagingParam->pagingFrame = (sfn % 1024); + rcvdF1apPagingParam->i_s = ((uint32_t)(floor(rcvdF1apPagingParam->ueId / N)) % ns); + + DU_LOG("\nINFO --> DU APP : Successfully filled paging parameter in DuCellCb"); + memcpy(&cellCb->tmpPagingInfoOfUe, rcvdF1apPagingParam, sizeof(DuPagingMsg)); + } + else + { + DU_LOG("\nINFO --> DU APP : FillPagingInfoInCellCb(): Received null pointer"); + return RFAILED; + } + return ROK; +} + + /********************************************************************** End of file **********************************************************************/ diff --git a/src/du_app/du_cell_mgr.h b/src/du_app/du_cell_mgr.h index ee26fe4e5..5cd9c0d6a 100644 --- a/src/du_app/du_cell_mgr.h +++ b/src/du_app/du_cell_mgr.h @@ -26,6 +26,7 @@ void duProcF1SetupRsp(); uint8_t duGetCellCb(uint16_t cellId, DuCellCb **cellCb); uint8_t BuildAndSendSliceConfigReq(RrmPolicy *rrmPolicy[], uint8_t totalRrrmPolicy, uint8_t totalSliceCfgReq); uint8_t BuildAndSendSliceReCfgReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceReCfg); +uint8_t FillPagingInfoInCellCb(DuCellCb* cellCb, DuPagingMsg *rcvdF1apPagingParam); #endif /********************************************************************** End of file diff --git a/src/du_app/du_cfg.c b/src/du_app/du_cfg.c index d991cba15..1b3b6a0a3 100644 --- a/src/du_app/du_cfg.c +++ b/src/du_app/du_cfg.c @@ -27,6 +27,7 @@ #include "du_cfg.h" #include "du_mgr.h" #include "du_utils.h" +#include "du_f1ap_conversions.h" #include "OCTET_STRING.h" #include "BIT_STRING.h" #include "odu_common_codec.h" @@ -278,10 +279,9 @@ uint8_t readMacCfg() duCfgParam.macCellCfg.sib1Cfg.searchSpaceZeroIndex = SEARCHSPACE_0_INDEX; duCfgParam.macCellCfg.sib1Cfg.sib1Mcs = DEFAULT_MCS; - GET_NUM_PAGING_OCC(duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg.ns, - duCfgParam.macCellCfg.sib1Cfg.pagingCfg.numPO); - if(duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg.firstPDCCHMontioringType != \ - PCCH_Config__firstPDCCH_MonitoringOccasionOfPO_PR_NOTHING) + duCfgParam.macCellCfg.sib1Cfg.pagingCfg.numPO = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg.ns; + if((duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg.firstPDCCHMontioringType != \ + PCCH_Config__firstPDCCH_MonitoringOccasionOfPO_PR_NOTHING) && (duCfgParam.macCellCfg.sib1Cfg.pagingCfg.numPO != 0)) { duCfgParam.macCellCfg.sib1Cfg.pagingCfg.poPresent = TRUE; memcpy(duCfgParam.macCellCfg.sib1Cfg.pagingCfg.pagingOcc, @@ -392,6 +392,27 @@ uint8_t readMacCfg() memcpy(duCfgParam.macCellCfg.plmnInfoList.snssai[sliceIdx], taiSliceSuppLst->snssai[sliceIdx], sizeof(Snssai)); } } + +#ifndef O1_ENABLE + + /*Note: Static Configuration, when O1 is not configuring the RRM policy*/ + RrmPolicyList rrmPolicy; + rrmPolicy.id[0] = 1; + rrmPolicy.resourceType = PRB; + rrmPolicy.rRMMemberNum = 1; + memcpy(rrmPolicy.rRMPolicyMemberList[0].mcc,duCfgParam.macCellCfg.plmnInfoList.plmn.mcc, 3*sizeof(uint8_t)); + memcpy(rrmPolicy.rRMPolicyMemberList[0].mnc,duCfgParam.macCellCfg.plmnInfoList.plmn.mnc, 3*sizeof(uint8_t)); + rrmPolicy.rRMPolicyMemberList[0].sst = 1; + rrmPolicy.rRMPolicyMemberList[0].sd[0] = 2; + rrmPolicy.rRMPolicyMemberList[0].sd[1] = 3; + rrmPolicy.rRMPolicyMemberList[0].sd[2] = 4; + rrmPolicy.rRMPolicyMaxRatio = 90; + rrmPolicy.rRMPolicyMinRatio = 30; + rrmPolicy.rRMPolicyDedicatedRatio = 10; + + cpyRrmPolicyInDuCfgParams(&rrmPolicy, 1, &duCfgParam.tempSliceCfg); + +#endif return ROK; } @@ -541,10 +562,10 @@ uint8_t fillServCellCfgCommSib(SrvCellCfgCommSib *srvCellCfgComm) BCCH_Config__modificationPeriodCoeff_n16; /* Configuring PCCH Config for SIB1 */ - pcchCfg.dfltPagingCycle = PagingCycle_rf256; + pcchCfg.dfltPagingCycle = convertPagingCycleEnumToValue(PagingCycle_rf256); pcchCfg.nAndPagingFrmOffsetType = PCCH_Config__nAndPagingFrameOffset_PR_oneT; pcchCfg.pageFrameOffset = 0; - pcchCfg.ns = PCCH_Config__ns_one; + pcchCfg.ns = convertNsEnumToValue(PCCH_Config__ns_one); pcchCfg.firstPDCCHMontioringType = PCCH_Config__firstPDCCH_MonitoringOccasionOfPO_PR_sCS30KHZoneT_SCS15KHZhalfT; memset(pcchCfg.firstPDCCHMontioringInfo, 0, sizeof(uint16_t)); pcchCfg.firstPDCCHMontioringInfo[0] = 44; @@ -1019,7 +1040,6 @@ uint8_t readCfg() * RFAILED - failure * * ****************************************************************/ -#ifdef O1_ENABLE uint8_t cpyRrmPolicyInDuCfgParams(RrmPolicyList rrmPolicy[], uint8_t policyNum, CopyOfRecvdSliceCfg *tempSliceCfg) { uint8_t policyIdx = 0, memberListIdx = 0, count = 0; @@ -1079,7 +1099,6 @@ uint8_t cpyRrmPolicyInDuCfgParams(RrmPolicyList rrmPolicy[], uint8_t policyNum, } return ROK; } -#endif /******************************************************************* * * @brief Reads config and posts message to du_app on completion diff --git a/src/du_app/du_cfg.h b/src/du_app/du_cfg.h index 709deeb0d..2a488d137 100644 --- a/src/du_app/du_cfg.h +++ b/src/du_app/du_cfg.h @@ -38,7 +38,7 @@ #endif #define DU_EGTP_PORT 39001 -#define CU_EGTP_PORT 39002 +#define CU_EGTP_PORT 39003 #define NR_PCI 1 #define NR_CELL_ID 1 @@ -1109,7 +1109,7 @@ typedef struct bcchCfg typedef struct pcchCfg { - uint8_t dfltPagingCycle; /* Default paging cycle */ + uint16_t dfltPagingCycle; /* Default paging cycle */ uint8_t nAndPagingFrmOffsetType; /*Number of PagingFrames in PagingCycle defined in terms of T.*/ uint8_t pageFrameOffset; /* Paging Frame offset */ uint8_t ns; /* Number of paging occassions in paging frame */ @@ -1274,6 +1274,39 @@ typedef struct f1SetupMsg char *f1MsgRspBuf; }F1SetupMsg; + +#ifndef O1_ENABLE +//RRM POLICY STRUCT + +typedef struct rRMPolicyMemberList +{ + uint8_t mcc[3]; + uint8_t mnc[3]; + uint8_t sd[3]; + uint8_t sst; +}RRMPolicyMemberList; + +typedef enum +{ + PRB, + PRB_UL, + PRB_DL, + RRC, + DRB +}RrmResourceType; + +typedef struct rrmPolicyList +{ + char id[1]; + RrmResourceType resourceType; + uint8_t rRMMemberNum; + RRMPolicyMemberList rRMPolicyMemberList[2]; + uint8_t rRMPolicyMaxRatio; + uint8_t rRMPolicyMinRatio; + uint8_t rRMPolicyDedicatedRatio; +}RrmPolicyList; +#endif + DuCfgParams duCfgParam; /*function declarations */ @@ -1282,10 +1315,7 @@ uint8_t readClCfg(); uint8_t readCfg(); uint8_t duReadCfg(); uint16_t calcSliv(uint8_t startSymbol, uint8_t lengthSymbol); - -#ifdef O1_ENABLE uint8_t cpyRrmPolicyInDuCfgParams(RrmPolicyList rrmPolicy[], uint8_t policyNum, CopyOfRecvdSliceCfg *tempSliceCfg); -#endif #endif /* __DU_CONFIG_H__ */ diff --git a/src/du_app/du_e2ap_msg_hdl.c b/src/du_app/du_e2ap_msg_hdl.c index 6c18c3973..c45ed3be8 100644 --- a/src/du_app/du_e2ap_msg_hdl.c +++ b/src/du_app/du_e2ap_msg_hdl.c @@ -57,7 +57,7 @@ uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId) { uint8_t unused = 0; uint8_t byteSize = 4; - uint8_t val = 1; + uint8_t gnbId = 1; uint8_t ret = ROK; /* Allocate Buffer size */ @@ -72,22 +72,22 @@ uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId) else { buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \ - gNbId->global_gNB_ID.plmn_id.buf); + gNbId->global_gNB_ID.plmn_id.buf); /* fill gND Id */ gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID; /* Allocate Buffer size */ gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t); gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP; DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \ - gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size); + gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size); if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP) { - DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer"); - ret = RFAILED; + DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer"); + ret = RFAILED; } else { - fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, val); + fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId); } } return ret; diff --git a/src/du_app/du_egtp.c b/src/du_app/du_egtp.c index 76ec0cf74..2a486c639 100644 --- a/src/du_app/du_egtp.c +++ b/src/du_app/du_egtp.c @@ -285,7 +285,7 @@ uint8_t egtpCfgReq(Pst *pst, EgtpConfig egtpCfg) memcpy(&egtpCb.egtpCfg, &egtpCfg, sizeof(EgtpConfig)); egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr); - egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT; + egtpCb.recvTptSrvr.addr.port = EGTP_RECVR_PORT; egtpCb.dstCb.dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr); egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort; @@ -877,7 +877,7 @@ uint8_t egtpSendMsg(Buffer *mBuf) info.region = DU_APP_MEM_REGION; info.pool = DU_POOL; - dstAddr.port = EGTP_DFLT_PORT; + dstAddr.port = EGTP_RECVR_PORT; dstAddr.address = egtpCb.dstCb.dstIp; ret = cmInetSendMsg(&(egtpCb.dstCb.sendTptSrvr.sockFd), &dstAddr, &info, \ diff --git a/src/du_app/du_egtp.h b/src/du_app/du_egtp.h index 2f158e25b..b8c7b4edd 100644 --- a/src/du_app/du_egtp.h +++ b/src/du_app/du_egtp.h @@ -21,7 +21,7 @@ #ifndef __DU_EGTP_H__ #define __DU_EGTP_H__ -#define EGTP_DFLT_PORT 2152 +#define EGTP_RECVR_PORT 2152 /* As per the spec 29.281, the registered port number for GTP-U is 2152 */ #define EGTP_MAX_HDR_LEN 40 #define EGTP_MAX_MSG_RECV 10 diff --git a/src/du_app/du_f1ap_conversions.c b/src/du_app/du_f1ap_conversions.c index cb2b9df8c..50fff853d 100644 --- a/src/du_app/du_f1ap_conversions.c +++ b/src/du_app/du_f1ap_conversions.c @@ -20,20 +20,8 @@ * its corresponding values used in DU and vice-versa */ #include "common_def.h" -#include "SN-FieldLengthUM.h" -#include "SN-FieldLengthAM.h" -#include "T-PollRetransmit.h" -#include "PollPDU.h" -#include "PollByte.h" -#include "UL-AM-RLC.h" -#include "T-Reassembly.h" -#include "T-StatusProhibit.h" -#include "DL-AM-RLC.h" -#include "RLC-Config.h" -#include "RLC-BearerConfig.h" #include "BSR-Config.h" -#include "PUCCH-Resource.h" -#include "du_app_rlc_inf.h" +#include "du_f1ap_conversions.h" /************************************************************************ * @@ -1182,6 +1170,134 @@ long convertLcSrDelayTmrValueToEnum(uint16_t delayTimer) } } +/************************************************************************ + * + * @brief Converts actual values into enum value of Paging DRX cycle + * + * @details + * + * Function : convertPagingCycleValueToEnum + * + * Functionality: As per Spec 38.331, + * Converts Actual values into enum value of Paging DRX cycle + * + * + * @params[in] Actual value of PagingDRX + * @return Enum value of DRX cycle + * + * **********************************************************************/ +e_PagingDRX convertPagingCycleValueToEnum(uint16_t pagingDrxCycle) +{ + switch(pagingDrxCycle) + { + case 32: + return PagingDRX_v32; + case 64: + return PagingDRX_v64; + case 128: + return PagingDRX_v128; + case 256: + return PagingDRX_v256; + default: + return PagingDRX_v32; + } +} + +/************************************************************************ + * + * @brief Converts enum values into actual value of Paging DRX cycle + * + * @details + * + * Function : convertPagingCycleEnumToValue + * + * Functionality: As per Spec 38.331, + * Converts enum values into actual value of Paging DRX cycle + * + * + * @params[in] Enum value of PagingDRX + * @return Actual value of DRX cycle + * Note: Returning the MAX value in case of Incorrect Enum Value as DRX + * cycle is MIN of Various DRX cycle + * + * **********************************************************************/ +uint16_t convertPagingCycleEnumToValue(e_PagingDRX pagingDrx) +{ + switch(pagingDrx) + { + case PagingDRX_v32: + return 32; + case PagingDRX_v64: + return 64; + case PagingDRX_v128: + return 128; + case PagingDRX_v256: + return 256; + default: + return 256; + } +} +/************************************************************************ + * + * @brief Converts enum values into actual value of Num of Paging Ocassions + * + * @details + * + * Function : convertPagingOccEnumToValue + * + * Functionality: As per Spec 38.331, + * Converts enum values into actual value of Num of Paging Ocassion + * + * + * @params[in] Enum value of Ns + * @return Actual value of Num of Paging Ocassions + * + * **********************************************************************/ +uint8_t convertNsEnumToValue(e_PCCH_Config__ns Ns) +{ + switch(Ns) + { + case PCCH_Config__ns_four: + return 4; + case PCCH_Config__ns_two: + return 2; + case PCCH_Config__ns_one: + return 1; + default: + return 0; + } +} + +/************************************************************************ + * + * @brief Converts actual values into enum value of Num of Paging Ocassions + * + * @details + * + * Function : convertNsValueToEnum + * + * Functionality: As per Spec 38.331, + * Converts actual values into enum value of Num of Paging Ocassions + * + * + * @params[in] Actual value of Num of Paging Ocassions + * @return Enum value of Ns + * + * **********************************************************************/ +e_PCCH_Config__ns convertNsValueToEnum(uint8_t numPO) +{ + switch(numPO) + { + case 1: + return PCCH_Config__ns_one; + case 2: + return PCCH_Config__ns_two; + case 4: + return PCCH_Config__ns_four; + default: + return PCCH_Config__ns_one; + } +} /********************************************************************** End of file **********************************************************************/ diff --git a/src/du_app/du_f1ap_conversions.h b/src/du_app/du_f1ap_conversions.h index f42fe9ea5..508ffd5f4 100644 --- a/src/du_app/du_f1ap_conversions.h +++ b/src/du_app/du_f1ap_conversions.h @@ -18,6 +18,20 @@ /* This file contains definitions of F1AP conversion functions */ +#include "RLC-BearerConfig.h" +#include "RLC-Config.h" +#include "SN-FieldLengthAM.h" +#include "SN-FieldLengthUM.h" +#include "T-PollRetransmit.h" +#include "PollPDU.h" +#include "PollByte.h" +#include "T-Reassembly.h" +#include "T-StatusProhibit.h" +#include "PUCCH-Resource.h" +#include "PagingDRX.h" +#include "PCCH-Config.h" +#include "du_app_rlc_inf.h" + RLC_BearerConfig__servedRadioBearer_PR covertRbTypeFromIntEnumToRrcEnum(RlcRbType rbType); RLC_Config_PR covertRlcModeFromIntEnumToRrcEnum(RlcMode mode); SN_FieldLengthAM_t covertAmSnLenFromIntEnumToRrcEnum(SnLenAm snLen); @@ -26,7 +40,7 @@ SN_FieldLengthUM_t covertUmSnLenFromIntEnumToRrcEnum(SnLenUm snLen); SnLenUm covertUmSnLenFromRrcEnumToIntEnum(SN_FieldLengthUM_t snLen); T_PollRetransmit_t covertPollRetxTmrValueToEnum(uint16_t pollRetxTmr); uint16_t covertPollRetxTmrEnumToValue(uint8_t pollRetxTmrCfg); -PollPDU_t covertPollPduValueToEnum(int16_t pollPdu); +PollPDU_t covertPollPduValueToEnum(int32_t pollPdu); int32_t covertPollPduEnumToValue(uint8_t pollPduCfg); PollByte_t covertPollByteValueToEnum(int32_t pollByte); int32_t covertPollByteEnumToValue(uint16_t pollBytesCfg); @@ -41,6 +55,11 @@ long convertBsrPeriodicTmrValueToEnum(int16_t periodicTmr); long convertBsrRetxTmrValueToEnum(uint16_t retxTmr); long convertLcSrDelayTmrValueToEnum(uint16_t delayTimer); +e_PagingDRX convertPagingCycleValueToEnum(uint16_t pagingDrxCycle); +uint16_t convertPagingCycleEnumToValue(e_PagingDRX pagingDrx); +uint8_t convertNsEnumToValue(e_PCCH_Config__ns Ns); +e_PCCH_Config__ns convertNsValueToEnum(uint8_t numPO); + /********************************************************************** End of file **********************************************************************/ diff --git a/src/du_app/du_f1ap_msg_hdl.c b/src/du_app/du_f1ap_msg_hdl.c index e0064dc0f..63630e6cc 100644 --- a/src/du_app/du_f1ap_msg_hdl.c +++ b/src/du_app/du_f1ap_msg_hdl.c @@ -113,6 +113,8 @@ #include "du_sys_info_hdl.h" #include "du_e2ap_msg_hdl.h" #include "du_f1ap_conversions.h" +#include "CNUEPagingIdentity.h" +#include "PCCH-Config.h" #ifdef O1_ENABLE #include "CmInterface.h" @@ -5338,7 +5340,7 @@ uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg) /* Multi CSI */ if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0)) { - pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP; + pucchCfg->multi_CSI_PUCCH_ResourceList = NULLP; DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList)); if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP) { @@ -15308,6 +15310,236 @@ uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg) freeAperDecodeUeContextReleaseCommand(f1apMsg); return ret; } + +/************************************************************** + * + * @brief free the memory allocated by aper decoder for paging + * + * @details + * + * Function : freeAperDecodePagingMsg + * + * Functionality: + * - free the memory allocated by aper decoder for + * the paging f1ap msg + * + * @params[in] Paging_t *paging + * @return ROK - success + * RFAILED - failure + * + ****************************************************************/ +void freeAperDecodePagingMsg(Paging_t *paging) +{ + uint8_t ieIdx, cellIdx; + PagingCell_ItemIEs_t *pagingCellItemIes; + PagingCell_Item_t *pagingCellItem; + PagingCell_list_t *pagingCelllist; + + if(paging) + { + if(paging->protocolIEs.list.array) + { + for(ieIdx=0 ; ieIdxprotocolIEs.list.count; ieIdx++) + { + if(paging->protocolIEs.list.array[ieIdx]) + { + switch(paging->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_ID_id_UEIdentityIndexValue: + { + free(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf); + 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) + { + free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf); + } + free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.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; + free(pagingCellItem->nRCGI.pLMN_Identity.buf); + free(pagingCellItem->nRCGI.nRCellIdentity.buf); + } + free(pagingCelllist->list.array[cellIdx]); + } + } + free(pagingCelllist->list.array); + } + break; + } + } + free(paging->protocolIEs.list.array[ieIdx]); + } + } + free(paging->protocolIEs.list.array); + + } + } +} + +/************************************************************** + * + * @brief processing the paging f1ap msg received from CU + * + * @details + * + * Function : procPagingMsg + * + * Functionality: + * - processing the paging f1ap msg received from CU + * + * @params[in] F1AP_PDU_t *f1apMsg + * @return ROK - success + * RFAILED - failure + * + * + ****************************************************************/ +uint8_t procPagingMsg(F1AP_PDU_t *f1apMsg) +{ + uint8_t ieIdx = 0, cellListIdx = 0; + uint16_t cellId = 0, cellIdx = 0; + Paging_t *paging = NULLP; + PagingCell_list_t *pagingCelllist = NULLP; + PagingCell_ItemIEs_t *pagingCellItemIes = NULLP; + PagingCell_Item_t *pagingCellItem = NULLP; + DuPagingMsg *tmpPagingParam = NULLP; + + DU_LOG("\nINFO --> DU APP : Processing the Paging Message"); + paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging; + if(paging) + { + if(paging->protocolIEs.list.array) + { + DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg)); + if(tmpPagingParam == NULLP) + { + DU_LOG("\nERROR --> DU APP : Memory Allocation Failure in procPagingMsg"); + freeAperDecodePagingMsg(paging); + return RFAILED; + } + for(ieIdx=0 ; ieIdxprotocolIEs.list.count; ieIdx++) + { + if(paging->protocolIEs.list.array[ieIdx]) + { + switch(paging->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_ID_id_UEIdentityIndexValue: + { + bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10,\ + &tmpPagingParam->ueId); + break; + } + + case ProtocolIE_ID_id_PagingIdentity: + { + switch(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present) + { + case PagingIdentity_PR_cNUEPagingIdentity: + { + if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity) + { + bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.\ + cNUEPagingIdentity->choice.fiveG_S_TMSI, &tmpPagingParam->sTmsi); + + } + break; + } + case PagingIdentity_PR_rANUEPagingIdentity: + { + /*TODO: This Identifier is specific to RAN Initiated Paging – Connected Mode Paging*/ + break; + } + default: + { + DU_LOG("ERROR --> DU APP: Invalid UE Paging Identity, Skipping this Paging Message:"); + continue; + } + } + } + + case ProtocolIE_ID_id_PagingDRX: + { + tmpPagingParam->pagingDrxPres = TRUE; + tmpPagingParam->pagingDrx = convertPagingCycleEnumToValue(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX); + break; + } + + case ProtocolIE_ID_id_PagingPriority: + { + tmpPagingParam->pagPriority = paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority; + break; + } + + case ProtocolIE_ID_id_PagingCell_List: + { + pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list; + if(pagingCelllist->list.array) + { + for(cellListIdx = 0; cellListIdx < pagingCelllist->list.count; cellListIdx++) + { + if(pagingCelllist->list.array[cellListIdx]) + { + pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellListIdx]; + pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item; + bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId); + GET_CELL_IDX(cellId, cellIdx); + if(duCb.actvCellLst[cellIdx]) + { + /* fill Ue Paging information*/ + if(FillPagingInfoInCellCb(duCb.actvCellLst[cellIdx], tmpPagingParam)!= ROK) + { + DU_LOG("\nERROR --> DU APP : CellCb:%d not present to fill UE Paging Information",cellIdx); + continue; + } + } + else + { + DU_LOG("\nERROR --> F1AP : CellId:%d Not in Activelist",cellId); + continue; + } + } + } + } + break; + } + default: + { + DU_LOG("\nERROR --> F1AP : Incorrect Paging IE option"); + break; + } + } + } + } + } + } + DU_FREE(tmpPagingParam, sizeof(DuPagingMsg)); + freeAperDecodePagingMsg(paging); + + return ROK; +} + /************************************************************** * * @brief Handles received F1AP message and sends back response @@ -15436,6 +15668,11 @@ void F1APMsgHdlr(Buffer *mBuf) procF1UeContextReleaseCommand(f1apMsg); break; } + case InitiatingMessage__value_PR_Paging: + { + procPagingMsg(f1apMsg); + break; + } default: { DU_LOG("\nERROR --> F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]", diff --git a/src/du_app/du_mgr.h b/src/du_app/du_mgr.h index 7dad91b15..8678e1099 100644 --- a/src/du_app/du_mgr.h +++ b/src/du_app/du_mgr.h @@ -178,6 +178,24 @@ typedef struct slotInfo uint16_t slot; }SlotInfo; +typedef struct pagingMsg +{ + /*Note: Paging UEID is extracted from 5gSTMSI as per Spec 38.304, Sec 7.1. + *This is not same as DU-UE_F1AP_ID or CU_UE_F1AP_ID*/ + uint16_t ueId; /* UE Identifier from CU*/ + + /*TODO: When RAN Inititated Paging will be supported then I-RNTI will be + * added as a choice for UE Identity along with S-TMSI*/ + uint64_t sTmsi; /* UE Paging Identity: S-TMSI */ + bool pagingDrxPres; /* flag to indicate paging drx present or not */ + uint16_t pagingDrx; /* UE specific paging drx */ + uint8_t pagPriority; /* Paging priority */ + uint16_t pagingFrame; /* paging frame */ + uint16_t pagingFrameOffset; /* paging offset */ + uint8_t i_s; /* Index points to PO from the sub-frame pattern */ + uint16_t T; /* T is DRX cycle of the UE */ +}DuPagingMsg; + typedef struct duCellCb { uint16_t cellId; /* Internal cell Id */ @@ -188,6 +206,7 @@ typedef struct duCellCb uint32_t numActvUes; /* Total Active UEs */ DuUeCb ueCb[MAX_NUM_UE]; /* Stores UE context */ SlotInfo currSlotInfo; + DuPagingMsg tmpPagingInfoOfUe; /* UE paging information */ }DuCellCb; typedef struct duLSapCb diff --git a/src/du_app/du_sys_info_hdl.c b/src/du_app/du_sys_info_hdl.c index 3b3194782..9aeced60c 100644 --- a/src/du_app/du_sys_info_hdl.c +++ b/src/du_app/du_sys_info_hdl.c @@ -55,6 +55,7 @@ #include "SIB1.h" #include "odu_common_codec.h" #include "du_sys_info_hdl.h" +#include "du_f1ap_conversions.h" void FreeSib1Msg(SIB1_t *sib1Msg); uint8_t FreqInfoUlret = RFAILED; @@ -1309,8 +1310,8 @@ uint8_t fillFirstPdcchMonitoringOcc(struct PCCH_Config__firstPDCCH_MonitoringOcc firstPO->present = srcPcchCfg->firstPDCCHMontioringType; - GET_NUM_PAGING_OCC(srcPcchCfg->ns, numPO); - if(srcPcchCfg->ns == 0) + numPO = srcPcchCfg->ns; + if(numPO == 0) { DU_LOG("\nINFO --> DU APP : Paging Occasions is ZERO, no need to fill further"); return ROK; @@ -1441,7 +1442,7 @@ uint8_t BuildPcchConfig(PCCH_Config_t *pcchCfg) duPcchCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg; - pcchCfg->defaultPagingCycle = duPcchCfg.dfltPagingCycle; + pcchCfg->defaultPagingCycle = convertPagingCycleValueToEnum(duPcchCfg.dfltPagingCycle); pcchCfg->nAndPagingFrameOffset.present = duPcchCfg.nAndPagingFrmOffsetType; switch(pcchCfg->nAndPagingFrameOffset.present) { @@ -1507,7 +1508,7 @@ uint8_t BuildPcchConfig(PCCH_Config_t *pcchCfg) return RFAILED; } } - pcchCfg->ns = duPcchCfg.ns; + pcchCfg->ns = convertNsValueToEnum(duPcchCfg.ns); DU_ALLOC(pcchCfg->firstPDCCH_MonitoringOccasionOfPO, \ sizeof(struct PCCH_Config__firstPDCCH_MonitoringOccasionOfPO)); diff --git a/src/phy_stub/phy_stub_msg_hdl.c b/src/phy_stub/phy_stub_msg_hdl.c index 7098e0a75..94b73920f 100644 --- a/src/phy_stub/phy_stub_msg_hdl.c +++ b/src/phy_stub/phy_stub_msg_hdl.c @@ -706,7 +706,6 @@ uint16_t l1BuildAndSendSlotIndication() memset(&pst, 0, sizeof(Pst)); FILL_PST_PHY_STUB_TO_LWR_MAC(pst, EVT_PHY_STUB_SLOT_IND); - ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf); if(!mBuf) { diff --git a/src/ric_stub/ric_e2ap_msg_hdl.c b/src/ric_stub/ric_e2ap_msg_hdl.c index 4bed18a7a..b810dda47 100644 --- a/src/ric_stub/ric_e2ap_msg_hdl.c +++ b/src/ric_stub/ric_e2ap_msg_hdl.c @@ -104,7 +104,7 @@ uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId) { uint8_t unused = 4; uint8_t byteSize = 3; - uint8_t val = 16; + uint8_t ricVal= 1; if(ricId != NULLP) { ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t); @@ -113,7 +113,7 @@ uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId) /* fill ric Id */ ricId->ric_ID.size = byteSize * sizeof(uint8_t); RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size); - fillBitString(&ricId->ric_ID, unused, byteSize, val); + fillBitString(&ricId->ric_ID, unused, byteSize, ricVal); } return ROK; } diff --git a/src/ric_stub/ric_stub.c b/src/ric_stub/ric_stub.c index e27f2acb4..200e27d62 100644 --- a/src/ric_stub/ric_stub.c +++ b/src/ric_stub/ric_stub.c @@ -82,6 +82,8 @@ uint8_t tst() /* Start RIC-SCTP to listen on incoming connection */ sctpCfgReq(); + /*Sleep is introduced for GDB to increase the waiting time for RIC Configuration from DUAPP*/ + sleep(1); sctpStartReq(); return ROK;