src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "du_tmr.h"
  22 #include "ckw.h"
  23 #include "ckw.x"
  24 #include "kwu.h"
  25 #include "kwu.x"
  26 #include "lkw.h"
  27 #include "lrg.h"
  28 #include "legtp.h"
  29 #include "lkw.x"
  30 #include "lrg.x"
  31 #include "F1AP-PDU.h"
  32 #include "InitiatingMessage.h"
  33 #include "SuccessfulOutcome.h"
  34 #include "du_app_mac_inf.h"
  35 #include "du_cfg.h"
  36 #include "du_app_rlc_inf.h"
  37 #include "du_e2ap_mgr.h"
  38 #include "du_e2ap_msg_hdl.h"
  39 #include "du_mgr_main.h"
  40 #include "du_mgr.h"
  41 #include "du_utils.h"
  42 #include "du_ue_mgr.h"
  43 #include "RAT-Type.h"
  44 #include "NRFreqInfo.h"
  45 #include "NRCGI.h"
  46 #include "TDD-Info.h"
  47 #include "NR-Mode-Info.h"
  48 #include "ServedPLMNs-List.h"
  49 #include "GNB-DU-Served-Cells-List.h"
  50 #include "Served-Cell-Information.h"
  51 #include "ProtocolExtensionContainer.h"
  52 #include "RRC-Version.h"
  53 #include "FDD-Info.h"
  54 #include "FreqBandNrItem.h"
  55 #include "ServedPLMNs-Item.h"
  56 #include "GNB-DU-Served-Cells-Item.h"
  57 #include "SliceSupportItem.h"
  58 #include "FeatureSetUplinkPerCC.h"
  59 #include "SliceSupportItem.h"
  60 #include "Served-Cells-To-Modify-Item.h"
  61 #include "Served-Cells-To-Delete-List.h"
  62 #include "Served-Cells-To-Delete-Item.h"
  63 #include "QoSInformation.h"
  64 #include "ULUPTNLInformation-ToBeSetup-List.h"
  65 #include "DRB-Information.h"
  66 #include "DRBs-ToBeSetup-Item.h"
  67 #include "DRBs-ToBeSetupMod-Item.h"
  68 #include "DRBs-ToBeModified-Item.h"
  69 #include "CUtoDURRCInformation.h"
  70 #include "SCell-ToBeSetup-List.h"
  71 #include "SRBs-ToBeSetup-List.h"
  72 #include "DRBs-ToBeSetup-List.h"
  73 #include "SRBs-ToBeSetup-Item.h"
  74 #include "DRBs-ToBeModified-List.h"
  75 #include "RRCContainer.h"
  76 #include "UE-CapabilityRAT-ContainerList.h"
  77 #include "DRBs-Setup-List.h"
  78 #include "CellGroupConfig.h"
  79 #include "ResetAll.h"
  80 #include "ResetType.h"
  81 #include "Cells-to-be-Activated-List.h"
  82 #include "GNB-CU-Name.h"
  83 #include "SRBs-SetupMod-List.h"
  84 #include "DRBs-SetupMod-List.h"
  85 #include "DRBs-ToBeSetupMod-List.h"
  86 #include "PagingCell-Item.h"
  87 #include "PagingCell-list.h"
  88 #include "QoS-Characteristics.h"
  89 #include "ULUPTNLInformation-ToBeSetup-Item.h"
  90 #include "Flows-Mapped-To-DRB-Item.h"
  91 #include "NonDynamic5QIDescriptor.h"
  92 #include "Dynamic5QIDescriptor.h"
  93 #include "FeatureSetDownlinkPerCC.h"
  94 #include "FeatureSets.h"
  95 #include "UE-NR-Capability.h"
  96 #include "UE-CapabilityRAT-Container.h"
  97 #include "UE-CapabilityRAT-ContainerListRRC.h"
  98 #include "GNB-DU-System-Information.h"
  99 #include "CellGroupConfigRrc.h"
 100 #include "MAC-CellGroupConfig.h"
 101 #include "SchedulingRequestConfig.h"
 102 #include "SchedulingRequestToAddMod.h"
 103 #include "BSR-Config.h"
 104 #include "TAG-Config.h"
 105 #include "TAG.h"
 106 #include "PHR-Config.h"
 107 #include "RLC-Config.h"
 108 #include "UL-AM-RLC.h"
 109 #include "DL-AM-RLC.h"
 110 #include "LogicalChannelConfig.h"
 111 #include "RLC-BearerConfig.h"
 112 #include "PhysicalCellGroupConfig.h"
 113 #include "SpCellConfig.h"
 114 #include "TDD-UL-DL-ConfigDedicated.h"
 115 #include "ServingCellConfig.h"
 116 #include "ControlResourceSet.h"
 117 #include "SearchSpace.h"
 118 #include "PDCCH-Config.h"
 119 #include "PDSCH-TimeDomainResourceAllocation.h"
 120 #include "PDSCH-TimeDomainResourceAllocationList.h"
 121 #include "PDSCH-CodeBlockGroupTransmission.h"
 122 #include "PDSCH-ServingCellConfig.h"
 123 #include "DMRS-DownlinkConfig.h"
 124 #include "PDSCH-Config.h"
 125 #include "BWP-DownlinkDedicated.h"
 126 #include "BWP-Downlink.h"
 127 #include "PUSCH-TimeDomainResourceAllocation.h"
 128 #include "PUSCH-TimeDomainResourceAllocationList.h"
 129 #include "DMRS-UplinkConfig.h"
 130 #include "PUSCH-Config.h"
 131 #include "SRS-ResourceId.h"
 132 #include "SRS-Resource.h"
 133 #include "SRS-ResourceSet.h"
 134 #include "SRS-Config.h"
 135 #include "BWP-UplinkDedicated.h"
 136 #include "PUSCH-ServingCellConfig.h"
 137 #include "UplinkConfig.h"
 138 #include "DUtoCURRCContainer.h"
 139 #include "GBR-QoSFlowInformation.h"
 140 #include "QoSFlowLevelQoSParameters.h"
 141 #include "PUCCH-Config.h"
 142 #include "PUCCH-ResourceSet.h"
 143 #include "PUCCH-Resource.h"
 144 #include "PUCCH-PowerControl.h"
 145 #include "P0-PUCCH.h"
 146 #include "PUCCH-PathlossReferenceRS.h"
 147 #include "PUCCH-format0.h"
 148 #include "PUCCH-format1.h"
 149 #include "PUCCH-format2.h"
 150 #include "PUCCH-format3.h"
 151 #include "PUCCH-format4.h"
 152 #include "PUCCH-FormatConfig.h"
 153 #include "SchedulingRequestResourceConfig.h"
 154 #include<ProtocolIE-Field.h>
 155 #include "ProtocolExtensionField.h"
 156 #include "odu_common_codec.h"
 157 #include "du_mgr.h"
 158 #include "du_cell_mgr.h"
 159 #include "du_f1ap_msg_hdl.h"
 160 #include "DRBs-Setup-Item.h"
 161 #include "DLUPTNLInformation-ToBeSetup-List.h"
 162 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 163 #include "UPTransportLayerInformation.h"
 164 #include "GTPTunnel.h"
 165 #include "SupportedSULFreqBandItem.h"
 166 #include "du_f1ap_conversions.h"
 167 #include "CNUEPagingIdentity.h"
 168 #include "PCCH-Config.h"
 169 #include "SCS-SpecificCarrier.h"
 170 #include "FrequencyInfoDL.h"
 171 #include "DownlinkConfigCommon.h"
 172 #include "FrequencyInfoUL.h"
 173 #include "UplinkConfigCommon.h"
 174 #include "TDD-UL-DL-ConfigCommon.h"
 175 #include "RACH-ConfigDedicated.h"
 176 #include "CFRA-SSB-Resource.h"
 177 #include "BWP-UplinkCommon.h"
 178 #include "ReconfigurationWithSync.h"
 179 #include "BCCH-DL-SCH-Message.h"
 180 #include "du_sys_info_hdl.h"
 181 #include "DRX-ConfigRrc.h"
 182 #include "MeasurementTimingConfigurationRrc.h"
 183 #include "MeasurementTimingConfigurationRrc-IEs.h"
 184 #include "MeasTimingList.h"
 185 #include "MeasTiming.h"
 186 #include "Cells-Status-List.h"
 187 #include "Cells-Status-Item.h"
 188
 189 #ifdef O1_ENABLE
 190 #include "CmInterface.h"
 191 extern StartupConfig g_cfg;
 192 #endif
 193
 194 extern DuCfgParams duCfgParam;
 195
 196 /******************************************************************
 197  *
 198  * @brief Function to fetch lcId based on DRB Id
 199  *
 200  * @details
 201  *
 202  *    Function : fetchLcId
 203  *
 204  *    @params[in] drbId
 205  *
 206  *    Functionality: Function to fetch lcId based on DRB Id
 207  *
 208  * Returns: lcId - SUCCESS
 209  *          RFAILED - FAILURE
 210  *****************************************************************/
 211
 212 uint8_t fetchLcId(uint8_t drbId)
 213 {
 214    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 215
 216    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 217    {
 218       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 219       {
 220          if(duCb.actvCellLst[cellIdx] != NULLP)
 221          {
 222             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duRlcUeCfg.numLcs;
 223             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 224             {
 225                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.rbId == drbId && \
 226                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.rbType == RB_TYPE_DRB)
 227                {
 228                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.lcId;
 229                   return lcId;
 230                }
 231             }
 232          }
 233       }
 234    }
 235    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 236    return RFAILED;
 237 }
 238
 239 /*******************************************************************
 240 *
 241 * @brief Adding F1AP pdu to reserved pdu list
 242 *
 243 * @details
 244 *
 245 *    Function : addToReservedF1apPduList
 246 *
 247 *    Functionality: Adding F1AP pdu to reserved pdu list.
 248 *     These pdu are awaiting aknowledgment from CU
 249 *
 250 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 251 *
 252 * @return ROK - success
 253 *         RFAILED - failure
 254 *
 255 * ****************************************************************/
 256 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 257 {
 258    CmLList         *node = NULLP;
 259    ReservedF1apPduInfo *pduInfo = NULLP;
 260    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 261    if(pduInfo)
 262    {
 263       DU_ALLOC(node, sizeof(CmLList));
 264       if(node)
 265       {
 266          pduInfo->transId = transId;
 267          pduInfo->f1apMsg = (void*) f1apPdu;
 268
 269          node->node = (PTR)pduInfo;
 270          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 271       }
 272    }
 273 }
 274
 275 /*******************************************************************
 276 *
 277 * @brief searching for F1AP pdu from ReservedF1apPduList
 278 *
 279 * @details
 280 *
 281 *    Function : searchFromReservedF1apPduList
 282 *
 283 *    Functionality: searching for F1AP pdu information
 284 *
 285 * @params[in] uint8_t transId
 286 *
 287 * @return pointer to F1AP_PDU_t
 288 *
 289 * ****************************************************************/
 290
 291 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 292 {
 293    CmLList         *node;
 294    ReservedF1apPduInfo *f1apPdu;
 295    if(duCb.reservedF1apPduList.count)
 296    {
 297       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 298       while(node)
 299       {
 300          f1apPdu = (ReservedF1apPduInfo*)node->node;
 301          if(f1apPdu->transId == transId)
 302          {
 303             return node;
 304          }
 305          node = node->next;
 306       }
 307    }
 308    return NULL;
 309 }
 310
 311 /*******************************************************************
 312 *
 313 * @brief deleting F1AP pdu information from ReservedF1apPduList
 314 *
 315 * @details
 316 *
 317 *    Function : deleteFromReservedF1apPduList
 318 *
 319 *    Functionality: deleting pdu information from ReservedF1apPduList
 320 *
 321 * @params[in] CmLList *node
 322 *
 323 * @return void
 324 *
 325 * ****************************************************************/
 326
 327 void deleteFromReservedF1apPduList(CmLList *node)
 328 {
 329    ReservedF1apPduInfo *f1apPdu;
 330
 331    if(node != NULL)
 332    {
 333       f1apPdu = (ReservedF1apPduInfo *)node->node;
 334       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 335       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 336       DU_FREE(node, sizeof(CmLList));
 337       node = NULL;
 338    }
 339 }
 340
 341 /*******************************************************************
 342  *
 343  * @brief Builds Uplink Info for NR
 344  *
 345  * @details
 346  *
 347  *    Function : BuildULNRInfo
 348  *
 349  *    Functionality: Building NR Uplink Info
 350  *
 351  * @params[in] NRFreqInfo_t *ulnrfreq
 352  * @return ROK     - success
 353  *         RFAILED - failure
 354  *
 355  * ****************************************************************/
 356 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 357 {
 358    uint8_t idx=0;
 359    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 360                        fdd.ulNrFreqInfo.nrArfcn;
 361    ulnrfreq->freqBandListNr.list.count = 1;
 362    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 363    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 364    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 365    {
 366       return RFAILED;
 367    }
 368    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 369    {
 370       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 371       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 372       {
 373          return RFAILED;
 374       }
 375    }
 376    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 377                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 378                                                                  freqBand[0].nrFreqBand;
 379    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 380    return ROK;
 381 }
 382 /*******************************************************************
 383  *
 384  * @brief Builds Downlink NR Info
 385  *
 386  * @details
 387  *
 388  *    Function : BuildDLNRInfo
 389  *
 390  *    Functionality: Building Downlink NR Info
 391  *
 392  * @params[in] NRFreqInfo_t *dlnrfreq
 393  * @return ROK     - success
 394  *         RFAILED - failure
 395  *
 396  * ****************************************************************/
 397 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 398 {
 399    uint8_t idx=0;
 400    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 401                        fdd.dlNrFreqInfo.nrArfcn;
 402    dlnrfreq->freqBandListNr.list.count = 1;
 403    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 404    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 405    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 406    {
 407       return RFAILED;
 408    }
 409    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 410    {
 411       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 412       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 413       {
 414          return RFAILED;
 415       }
 416    }
 417    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 418                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 419                                                                  freqBand[0].nrFreqBand;
 420    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 421
 422    return ROK;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Builds Nrcgi
 428  *
 429  * @details
 430  *
 431  *    Function : BuildNrcgi
 432  *
 433  *    Functionality: Building the PLMN ID and NR Cell id
 434  *
 435  * @params[in] NRCGI_t *nrcgi
 436  * @return ROK     - success
 437  *         RFAILED - failure
 438  *
 439  * ****************************************************************/
 440 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 441 {
 442    uint8_t ret;
 443    uint8_t byteSize = 5;
 444    /* Allocate Buffer Memory */
 445    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 446    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 447    if(nrcgi->pLMN_Identity.buf == NULLP)
 448    {
 449       return RFAILED;
 450    }
 451    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 452          nrcgi->pLMN_Identity.buf); // Building PLMN function
 453    if(ret != ROK)
 454    {
 455       return RFAILED;
 456    }
 457    /*nrCellIdentity*/
 458    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 459    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 460    if(nrcgi->nRCellIdentity.buf == NULLP)
 461    {
 462       return RFAILED;
 463    }
 464    fillBitString(&nrcgi->nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
 465
 466    return ROK;
 467 }
 468 /*******************************************************************
 469  *
 470  * @brief Builds FiveGStac
 471  *
 472  * @details
 473  *
 474  *    Function : BuildFiveGSTac
 475  *
 476  *    Functionality: Building the FiveGSTac
 477  *
 478  * @params[in] OCTET_STRING_t *fivegsTac
 479  * @return ROK     - success
 480  *         RFAILED - failure
 481  *
 482  * ****************************************************************/
 483 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 484 {
 485    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 486    if(servcell->fiveGS_TAC == NULLP)
 487    {
 488       return RFAILED;
 489    }
 490    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 491    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 492          sizeof(servcell->fiveGS_TAC->size));
 493    if(servcell->fiveGS_TAC->buf == NULLP)
 494    {
 495       return RFAILED;
 496    }
 497    servcell->fiveGS_TAC->buf[0] = 0;
 498    servcell->fiveGS_TAC->buf[1] = 0;
 499    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 500    return ROK;
 501 }
 502
 503 /*******************************************************************
 504  *
 505  * @brief fill nr frequency information
 506  *
 507  * @details
 508  *
 509  *    Function : fillNrTddInfo
 510  *
 511  *    Functionality: fill nr frequency information
 512  *
 513  * @params[in] NRFreqInfo_t freqInfo
 514  * @return ROK     - success
 515  *         RFAILED - failure
 516  *
 517  * ****************************************************************/
 518 uint8_t fillNrTddInfo(TDD_Info_t *tddInfo)
 519 {
 520    uint8_t elementCnt = 1, freqBandListIdx = 0, supportedBandIdx = 0;
 521    NRFreqInfo_t *freqInfo = NULLP;
 522
 523    if(tddInfo == NULLP)
 524    {
 525       DU_LOG("\nERROR  --> DU APP : Null pointer received at fillNrTddInfo");
 526       return RFAILED;
 527    }
 528
 529    freqInfo = &tddInfo->nRFreqInfo;
 530    freqInfo->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn;
 531
 532    freqInfo->freqBandListNr.list.count = elementCnt;
 533    freqInfo->freqBandListNr.list.size = freqInfo->freqBandListNr.list.count  * sizeof(FreqBandNrItem_t *);
 534    DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
 535    if(!freqInfo->freqBandListNr.list.array)
 536    {
 537       DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 538       return RFAILED;
 539    }
 540
 541    for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
 542    {
 543       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
 544       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
 545       {
 546          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 547          return RFAILED;
 548       }
 549
 550       freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
 551       f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
 552
 553       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
 554       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
 555       supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
 556
 557       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
 558             freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
 559       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
 560       {
 561          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 562          return RFAILED;
 563       }
 564
 565       for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
 566       {
 567          DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
 568                sizeof(SupportedSULFreqBandItem_t));
 569          if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
 570          {
 571             DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 572             return RFAILED;
 573          }
 574
 575          freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx]->freqBandIndicatorNr =\
 576          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.freqBand[0].sulBand[0];
 577       }
 578    }
 579
 580    tddInfo->transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs;
 581    tddInfo->transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb;
 582
 583    return ROK;
 584 }
 585
 586 /*******************************************************************
 587  *
 588  * @brief Builds NR Mode
 589  *
 590  * @details
 591  *
 592  *    Function : BuildNrMode
 593  *
 594  *    Functionality: Building the NR Mode
 595  *
 596  * @params[in] NR_Mode_Info_t *fdd
 597  * @return ROK     - success
 598  *         RFAILED - failure
 599  *
 600  * ****************************************************************/
 601 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 602 {
 603    uint8_t BuildDLNRInforet=0;
 604    uint8_t BuildULNRInforet=0;
 605
 606 #ifdef NR_TDD
 607    mode->present = NR_Mode_Info_PR_tDD;
 608 #else
 609    mode->present = NR_Mode_Info_PR_fDD;
 610 #endif
 611
 612    if(mode->present == NR_Mode_Info_PR_fDD)
 613    {
 614       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 615       if(mode->choice.fDD == NULLP)
 616       {
 617          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 618          return RFAILED;
 619       }
 620       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 621       if(BuildULNRInforet != ROK)
 622       {
 623          DU_LOG("\nERROR  --> Failed to build UlNrFreqInfo");
 624          return RFAILED;
 625       }
 626       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 627       if(BuildDLNRInforet != ROK)
 628       {
 629          DU_LOG("\nERROR  --> Failed to build DlNrFreqInfo");
 630          return RFAILED;
 631       }
 632       mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 633                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 634                                                           f1Mode.mode.fdd.ulTxBw.nrScs;
 635       mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 636                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 637                                                           f1Mode.mode.fdd.ulTxBw.nrb;
 638       mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 639                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 640                                                           f1Mode.mode.fdd.dlTxBw.nrScs;
 641       mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 642                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 643                                                           f1Mode.mode.fdd.dlTxBw.nrb;
 644    }
 645    else if(mode->present == NR_Mode_Info_PR_tDD)
 646    {
 647       DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
 648       if(mode->choice.tDD == NULLP)
 649       {
 650          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 651          return RFAILED;
 652       }
 653
 654       if(fillNrTddInfo(mode->choice.tDD) != ROK)
 655       {
 656          DU_LOG("\nERROR  --> Failed to fill Nr TDD information");
 657          return RFAILED;
 658       }
 659
 660    }
 661
 662    return ROK;
 663 }
 664 /*******************************************************************
 665  *
 666  * @brief Builds IE Extensions for Served PLMNs
 667  *
 668  * @details
 669  *
 670  *    Function : BuildExtensions
 671  *
 672  *    Functionality: Building the IE Extensions
 673  *
 674  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 675  * @return ROK     - success
 676  *         RFAILED - failure
 677  *
 678  * ****************************************************************/
 679 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 680 {
 681    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 682    uint8_t elementCnt=0, extensionCnt=0;
 683
 684    extensionCnt=IE_EXTENSION_LIST_COUNT;
 685    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 686    if((*ieExtend) == NULLP)
 687    {
 688       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 689       return RFAILED;
 690    }
 691    (*ieExtend)->list.count = extensionCnt;
 692    (*ieExtend)->list.size = \
 693                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 694    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 695    if((*ieExtend)->list.array == NULLP)
 696    {
 697       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 698       return RFAILED;
 699    }
 700    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 701    {
 702       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 703             sizeof(ServedPLMNs_ItemExtIEs_t));
 704       if((*ieExtend)->list.array[plmnidx] == NULLP)
 705       {
 706          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 707          return RFAILED;
 708       }
 709    }
 710
 711    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 712    idx = 0;
 713    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 714    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 715    (*ieExtend)->list.array[idx]->extensionValue.present = \
 716    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 717    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 718       list.count = elementCnt;
 719    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 720       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 721       list.count * sizeof(SliceSupportItem_t *);
 722
 723    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 724          list.array, elementCnt * sizeof(SliceSupportItem_t *));
 725    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 726          list.array == NULLP)
 727    {
 728       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 729       return RFAILED;
 730    }
 731
 732    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
 733    {
 734       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 735             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
 736       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 737             list.array[sliceLstIdx] == NULLP)
 738       {
 739          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 740          return RFAILED;
 741       }
 742       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 743          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
 744       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 745             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 746             extensionValue.choice.SliceSupportList.\
 747             list.array[sliceLstIdx]->sNSSAI.sST.size);
 748       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 749             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
 750       {
 751          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 752          return RFAILED;
 753       }
 754       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 755          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
 756          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
 757
 758       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 759             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 760       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 761             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
 762       {
 763          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 764          return RFAILED;
 765       }
 766       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 767          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
 768       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 769             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
 770             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 771       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 772             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
 773       {
 774          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 775          return RFAILED;
 776       }
 777       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 778       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
 779       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
 780       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 781    }
 782    return ROK;
 783 }
 784 /*******************************************************************
 785  *
 786  * @brief Builds Served PLMN
 787  *
 788  * @details
 789  *
 790  *    Function : BuildServedPlmn
 791  *
 792  *    Functionality: Building the Served PLMN
 793  *
 794  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 795  * @return ROK     - success
 796  *         RFAILED - failure
 797  *
 798  * ****************************************************************/
 799 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 800 {
 801    uint8_t  plmnidx;
 802    uint8_t  servPlmnCnt=1;
 803    uint8_t buildPlmnIdret=0;
 804    uint8_t BuildExtensionsret=0;
 805    srvplmn->list.count = servPlmnCnt;
 806    srvplmn->list.size = \
 807                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 808    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 809    if(srvplmn->list.array == NULLP)
 810    {
 811       return RFAILED;
 812    }
 813    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 814    {
 815       DU_ALLOC(srvplmn->list.array[plmnidx],\
 816             sizeof(ServedPLMNs_Item_t));
 817       if(srvplmn->list.array[plmnidx] == NULLP)
 818       {
 819          return RFAILED;
 820       }
 821    }
 822    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 823    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 824    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 825          srvplmn->list.array[0]->pLMN_Identity.buf);
 826    if(buildPlmnIdret!= ROK)
 827    {
 828       return RFAILED;
 829    }
 830    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 831    if(BuildExtensionsret!= ROK)
 832    {
 833       return RFAILED;
 834    }
 835    return ROK;
 836 }
 837
 838 /*******************************************************************
 839  *
 840  * @brief Frees Measurement Timing configuration
 841  *
 842  * @details
 843  *
 844  *    Function : FreeMeasTimingConf
 845  *
 846  *    Functionality: Frees Timing Configuration
 847  *
 848  * @params[in] MeasurementTimingConfigurationRrc_t measTimingConfRrc
 849  * @return ROK     - success
 850  *         RFAILED - failure
 851  *
 852  * ****************************************************************/
 853 void FreeMeasTimingConf(MeasurementTimingConfigurationRrc_t   measTimingConfRrc)
 854 {
 855    uint8_t measIeIdx = 0;
 856    MeasurementTimingConfigurationRrc_IEs_t  *measTimingConfIEs = NULLP;
 857
 858    if(measTimingConfRrc.criticalExtensions.choice.c1)
 859    {
 860       if(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf)
 861       {
 862          measTimingConfIEs = measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf;
 863          if(measTimingConfIEs->measTiming)
 864          {
 865             if(measTimingConfIEs->measTiming->list.array)
 866             {
 867                for(measIeIdx = 0; measIeIdx < measTimingConfIEs->measTiming->list.count; measIeIdx++)
 868                {
 869                   if(measTimingConfIEs->measTiming->list.array[measIeIdx])
 870                   {
 871                      DU_FREE(measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
 872                      DU_FREE(measTimingConfIEs->measTiming->list.array[measIeIdx], sizeof(MeasTiming_t));
 873                   }
 874                }
 875                DU_FREE(measTimingConfIEs->measTiming->list.array, measTimingConfIEs->measTiming->list.size);
 876             }
 877             DU_FREE(measTimingConfIEs->measTiming, sizeof(MeasTimingList_t));
 878          }
 879          DU_FREE(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(MeasurementTimingConfigurationRrc_IEs_t));
 880       }
 881       DU_FREE(measTimingConfRrc.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
 882    }
 883 }
 884
 885 /*******************************************************************
 886  *
 887  * @brief Builds MEasuerment Timing Configuration
 888  *
 889  * @details
 890  *
 891  *    Function : BuildMeasTimingConf
 892  *
 893  *    Functionality: Building Measurement Timing Configuration
 894  *
 895  * @params[in] Pointer to octet string to store Measurement timing
 896  *             Configuration
 897  * @return ROK     - success
 898  *         RFAILED - failure
 899  *
 900  * ****************************************************************/
 901 uint8_t BuildMeasTimingConf(OCTET_STRING_t *measTimingConf)
 902 {
 903    uint8_t ret = RFAILED;
 904    uint8_t elementCnt = 0;
 905    uint8_t measIeIdx = 0;
 906    asn_enc_rval_t encRetVal;
 907    MeasurementTimingConfigurationRrc_t   measTimingConfRrc;
 908    MeasurementTimingConfigurationRrc_IEs_t  *measTimingConfIEs = NULLP;
 909    struct MeasTiming__frequencyAndTiming  *freqAndTiming = NULLP;
 910
 911    while(true)
 912    {
 913       measTimingConfRrc.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
 914       DU_ALLOC(measTimingConfRrc.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
 915       if(!measTimingConfRrc.criticalExtensions.choice.c1)
 916       {
 917          DU_LOG("ERROR  --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for critical extension choice C1");
 918          break;
 919       }
 920       measTimingConfRrc.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
 921
 922       DU_ALLOC(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(MeasurementTimingConfigurationRrc_IEs_t));
 923       if(!measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf)
 924       {
 925          DU_LOG("ERROR  --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for measTimingConf");
 926          break;
 927       }
 928       measTimingConfIEs = measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf;
 929
 930       DU_ALLOC(measTimingConfIEs->measTiming, sizeof(MeasTimingList_t));
 931       if(!measTimingConfIEs->measTiming)
 932       {
 933          DU_LOG("ERROR  --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList");
 934          break;
 935       }
 936
 937       elementCnt = 1;
 938       measTimingConfIEs->measTiming->list.count = elementCnt;
 939       measTimingConfIEs->measTiming->list.size = elementCnt * sizeof(MeasTiming_t *);
 940       DU_ALLOC(measTimingConfIEs->measTiming->list.array, measTimingConfIEs->measTiming->list.size);
 941       if(!measTimingConfIEs->measTiming->list.array)
 942       {
 943          DU_LOG("ERROR  --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList array");
 944          break;
 945       }
 946
 947       for(measIeIdx = 0; measIeIdx < elementCnt; measIeIdx++)
 948       {
 949          DU_ALLOC(measTimingConfIEs->measTiming->list.array[measIeIdx], sizeof(MeasTiming_t));
 950          if(!measTimingConfIEs->measTiming->list.array[measIeIdx])
 951          {
 952             DU_LOG("ERROR  --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList array index %d", measIeIdx);
 953             break;
 954          }
 955       }
 956       if(measIeIdx < elementCnt)
 957       {
 958          break;
 959       }
 960
 961       measIeIdx = 0;
 962       DU_ALLOC(measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
 963       if(!measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming)
 964       {
 965          DU_LOG("ERROR  --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for frequencyAndTiming");
 966          break;
 967       }
 968       freqAndTiming = measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming;
 969       freqAndTiming->carrierFreq = MEAS_TIMING_ARFCN;
 970       freqAndTiming->ssbSubcarrierSpacing = duCfgParam.macCellCfg.ssbCfg.scsCmn;
 971       freqAndTiming->ssb_MeasurementTimingConfiguration.periodicityAndOffset.present = duCfgParam.macCellCfg.ssbCfg.ssbPeriod + 1;
 972       freqAndTiming->ssb_MeasurementTimingConfiguration.periodicityAndOffset.choice.sf20 = duCfgParam.macCellCfg.ssbCfg.ssbScOffset;
 973       freqAndTiming->ssb_MeasurementTimingConfiguration.duration = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfgDuration;
 974
 975       /* Encode the F1SetupRequest type as APER */
 976       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfRrc);
 977
 978       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 979       encBufSize = 0;
 980       encRetVal = uper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfRrc, PrepFinalEncBuf, encBuf);
 981
 982       /* Encode results */
 983       if(encRetVal.encoded == ENCODE_FAIL)
 984       {
 985          DU_LOG("\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration structure (at %s)\n",\
 986                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 987          break;
 988       }
 989       else
 990       {
 991          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Measurement Timing Configuration \n");
 992 #ifdef DEBUG_ASN_PRINT
 993          for(measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
 994          {
 995             printf("%x",encBuf[measIeIdx]);
 996          }
 997 #endif
 998
 999          measTimingConf->size = encBufSize;
1000          DU_ALLOC(measTimingConf->buf, encBufSize);
1001          if(measTimingConf->buf == NULLP)
1002          {
1003             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for MeasurementTimingConfiguration buffer");
1004             return RFAILED;
1005          }
1006          memcpy(measTimingConf->buf, &encBuf, encBufSize);
1007
1008          FreeMeasTimingConf(measTimingConfRrc);
1009
1010          ret = ROK;
1011          break;
1012       }
1013    }
1014    return ret;
1015 }
1016
1017 /*******************************************************************
1018  *
1019  * @brief Builds Served Cell List
1020  *
1021  * @details
1022  *
1023  *    Function : BuildServedCellList
1024  *
1025  *    Functionality: Building Served Cell List
1026  *
1027  * @params[in] PLMNID plmn
1028  * @return ROK     - success
1029  *         RFAILED - failure
1030  *
1031  * ****************************************************************/
1032
1033 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1034 {
1035    uint8_t  BuildNrcgiret=0;
1036    uint8_t  BuildFiveGSTacret=0;
1037    uint8_t  BuildServedPlmnret=0;
1038    uint8_t  BuildNrModeret=0;
1039    uint8_t  idx;
1040    uint8_t  plmnidx;
1041    uint8_t  plmnCnt=1;
1042    GNB_DU_Served_Cells_Item_t *srvCellItem;
1043    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1044    duServedCell->list.count = plmnCnt;
1045
1046    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1047    if(duServedCell->list.array == NULLP)
1048    {
1049       return RFAILED;
1050    }
1051    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1052    {
1053       DU_ALLOC(duServedCell->list.array[plmnidx],\
1054             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1055       if(duServedCell->list.array[plmnidx] == NULLP)
1056       {
1057          return RFAILED;
1058       }
1059    }
1060    idx = 0;
1061    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1062    duServedCell->list.array[idx]->criticality = Criticality_reject;
1063    duServedCell->list.array[idx]->value.present = \
1064                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1065    srvCellItem = \
1066                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1067    /*nRCGI*/
1068    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1069    if(BuildNrcgiret != ROK)
1070    {
1071       return RFAILED;
1072    }
1073    /*nRPCI*/
1074    srvCellItem->served_Cell_Information.nRPCI = \
1075                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1076
1077    /* fiveGS_TAC */
1078    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1079    if(BuildFiveGSTacret != ROK)
1080    {
1081       return RFAILED;
1082    }
1083
1084    /* Served PLMNs */
1085    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1086    if(BuildServedPlmnret !=ROK)
1087    {
1088       return RFAILED;
1089    }
1090
1091    /* nR Mode Info with FDD/TDD */
1092    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1093    if(BuildNrModeret != ROK)
1094    {
1095       return RFAILED;
1096    }
1097
1098    /*Measurement timing Config*/
1099    if(BuildMeasTimingConf(&srvCellItem->served_Cell_Information.measurementTimingConfiguration) != ROK)
1100       return RFAILED;
1101
1102    /* GNB DU System Information */
1103    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1104          sizeof(GNB_DU_System_Information_t));
1105    if(!srvCellItem->gNB_DU_System_Information)
1106    {
1107       return RFAILED;
1108    }
1109    /* MIB */
1110    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1111    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1112          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1113    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1114    {
1115       return RFAILED;
1116    }
1117    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1118          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1119
1120    /* SIB1 */
1121    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1122                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1123
1124    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1125          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1126    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1127    {
1128       return RFAILED;
1129    }
1130    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1131    {
1132       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1133                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1134    }
1135    return ROK;
1136 }
1137 /*******************************************************************
1138  *
1139  * @brief Builds RRC Version
1140  *
1141  * @details
1142  *
1143  *    Function : BuildRrcVer
1144  *
1145  *    Functionality: Building RRC Version
1146  *
1147  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1148  * @return ROK     - success
1149  *         RFAILED - failure
1150  *
1151  * ****************************************************************/
1152 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1153 {
1154    uint8_t rrcExt;
1155    uint8_t rrcLatest;
1156    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1157    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1158    if(rrcVer->latest_RRC_Version.buf == NULLP)
1159    {
1160       return RFAILED;
1161    }
1162    rrcVer->latest_RRC_Version.buf[0] = 0;
1163    rrcVer->latest_RRC_Version.bits_unused = 5;
1164    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1165    if(rrcVer->iE_Extensions == NULLP)
1166    {
1167       return RFAILED;
1168    }
1169    rrcVer->iE_Extensions->list.count = 1;
1170    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1171    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1172    if(rrcVer->iE_Extensions->list.array == NULLP)
1173    {
1174       return RFAILED;
1175    }
1176    rrcExt = 0;
1177    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1178          sizeof(RRC_Version_ExtIEs_t));
1179    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1180    {
1181       return RFAILED;
1182    }
1183    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1184                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1185    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1186    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1187                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1188    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1189       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1190    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1191          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1192          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1193    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1194          .Latest_RRC_Version_Enhanced.buf == NULLP)
1195    {
1196       return RFAILED;
1197    }
1198    rrcLatest = 0;
1199    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1200       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1201    rrcLatest++;
1202    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1203       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1204    rrcLatest++;
1205    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1206       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1207    return ROK;
1208 }
1209 /*******************************************************************
1210  *
1211  * @brief Sends F1 msg over SCTP
1212  *
1213  * @details
1214  *
1215  *    Function : sendF1APMsg
1216  *
1217  *    Functionality: Sends F1 msg over SCTP
1218  *
1219  * @params[in] Region region
1220  *             Pool pool
1221  * @return ROK     - success
1222  *         RFAILED - failure
1223  *
1224  * ****************************************************************/
1225 uint8_t sendF1APMsg()
1226 {
1227    Buffer *mBuf = NULLP;
1228
1229    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1230    {
1231       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1232       {
1233             ODU_PRINT_MSG(mBuf, 0,0);
1234
1235             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1236             {
1237                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1238                ODU_PUT_MSG_BUF(mBuf);
1239                return RFAILED;
1240             }
1241       }
1242       else
1243       {
1244          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1245          ODU_PUT_MSG_BUF(mBuf);
1246          return RFAILED;
1247       }
1248       ODU_PUT_MSG_BUF(mBuf);
1249    }
1250    else
1251    {
1252       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1253       return RFAILED;
1254    }
1255    return ROK;
1256 } /* sendF1APMsg */
1257
1258 /*******************************************************************
1259  *
1260  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1261  *
1262  * @details
1263  *
1264  *    Function :  FreeRrcVer
1265  *
1266  *    Functionality: deallocating the memory of function BuildRrcVer
1267  *
1268  * @params[in] RRC_Version_t *rrcVer
1269  *
1270  * @return void
1271  *
1272  *****************************************************************/
1273 void FreeRrcVer(RRC_Version_t *rrcVer)
1274 {
1275    if(rrcVer->latest_RRC_Version.buf != NULLP)
1276    {
1277       if(rrcVer->iE_Extensions != NULLP)
1278       {
1279          if(rrcVer->iE_Extensions->list.array != NULLP)
1280          {
1281             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1282             {
1283                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1284                      != NULLP)
1285                {
1286                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1287                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1288                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1289                }
1290                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1291             }
1292             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1293          }
1294          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1295       }
1296       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1297    }
1298 }
1299
1300 /*******************************************************************
1301  *
1302  * @brief Deallocating memory of TDD NrFreqInfo
1303  *
1304  * @details
1305  *
1306  *    Function : freeTddNrFreqInfo
1307  *
1308  *    Functionality: freeTddNrFreqInfo
1309  *
1310  * @params[in]  F1AP_PDU_t *f1apDuCfg
1311  *
1312  * @return ROK     - void
1313  *
1314  * ****************************************************************/
1315 void freeTddNrFreqInfo(NRFreqInfo_t *freqInfo)
1316 {
1317    uint8_t freqBandListIdx = 0, supportedBandIdx = 0;
1318
1319    if(freqInfo->freqBandListNr.list.array)
1320    {
1321       for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
1322       {
1323          if(freqInfo->freqBandListNr.list.array[freqBandListIdx])
1324          {
1325             if(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
1326             {
1327                for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
1328                {
1329                   DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1330                         sizeof(SupportedSULFreqBandItem_t));
1331                }
1332                DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
1333                      freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
1334
1335             }
1336             DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
1337          }
1338       }
1339       DU_FREE(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
1340    }
1341 }
1342
1343 /*******************************************************************
1344  *
1345  * @brief Deallocating memory allocated for Nr fdd frequencey mode
1346  *
1347  * @details
1348  *
1349  *    Function : freeFddNrFreqInfo
1350  *
1351  *    Functionality:Free memory allocated for Nr fdd frequencey mode
1352  *
1353  * @params[in]
1354  *
1355  * @return ROK     - void
1356  *
1357  * ****************************************************************/
1358 void freeFddNrFreqInfo(FDD_Info_t *fDD)
1359 {
1360    uint8_t arrIdx =0;
1361
1362    if(fDD != NULLP)
1363    {
1364       if(fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1365       {
1366          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1367                array[arrIdx], sizeof(FreqBandNrItem_t));
1368          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1369                fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1370       }
1371
1372       if(fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1373       {
1374          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.\
1375                array[arrIdx], sizeof(FreqBandNrItem_t));
1376          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1377                fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1378       }
1379       DU_FREE(fDD,sizeof(FDD_Info_t));
1380    }
1381 }
1382
1383 /*******************************************************************
1384  *
1385  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1386  *
1387  * @details
1388  *
1389  *    Function :  FreeServedCellList
1390  *
1391  *    Functionality:  deallocating the memory of function BuildServedCellList
1392
1393  *
1394  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1395  *
1396  * @return void
1397  *
1398  * ****************************************************************/
1399 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1400 {
1401    uint8_t   plmnCnt= 1;
1402    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1403    uint8_t  plmnIdx=0, sliceIdx=0;
1404    GNB_DU_Served_Cells_Item_t *srvCellItem;
1405    ServedPLMNs_Item_t  *servedPlmnItem;
1406    SliceSupportItem_t  *sliceSupportItem;
1407
1408    if(duServedCell->list.array!=NULLP)
1409    {
1410       if(duServedCell->list.array[0]!=NULLP)
1411       {
1412          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1413
1414          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1415                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1416          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1417                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1418
1419          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1420          {
1421             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1422                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1423             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1424          }
1425
1426          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1427          {
1428             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1429             {
1430                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1431                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1432
1433                if(servedPlmnItem->iE_Extensions != NULLP)
1434                {
1435                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1436                   {
1437                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1438                      {
1439                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1440                               SliceSupportList.list.array != NULLP)
1441                         {
1442                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1443                                  extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1444                            {
1445                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1446                                     SliceSupportList.list.array[sliceIdx] != NULLP)
1447                               {
1448                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1449                                                     extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1450
1451                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1452
1453                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1454                                  {
1455                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1456                                           sliceSupportItem->sNSSAI.sD->size);
1457                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1458                                  }
1459
1460                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1461                                        choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1462                               }
1463                            }
1464                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1465                                  SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1466                                  extensionValue.choice.SliceSupportList.list.size);
1467                         }
1468                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1469                               sizeof(ServedPLMNs_ItemExtIEs_t));
1470                      }
1471                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1472                            extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1473                   }
1474                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1475                }
1476                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1477                      sizeof(ServedPLMNs_Item_t));
1478             }
1479             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1480                   sizeof(ServedPLMNs_Item_t *));
1481          }
1482
1483          if(srvCellItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1484          {
1485             freeFddNrFreqInfo(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1486          }
1487          else
1488          {
1489             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD != NULLP)
1490             {
1491                freeTddNrFreqInfo(&srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1492                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1493             }
1494          }
1495
1496          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1497                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1498
1499          if(srvCellItem->gNB_DU_System_Information != NULLP)
1500          {
1501             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1502             {
1503                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1504                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1505             }
1506
1507             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1508             {
1509                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1510                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1511             }
1512
1513             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1514          }
1515
1516          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1517       }
1518       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1519    }
1520 }
1521
1522 /*******************************************************************
1523  *
1524  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1525  *
1526  * @details
1527  *
1528  *    Function :  FreeF1SetupReq
1529  *
1530  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1531  *
1532  * @params[in] F1AP_PDU_t *f1apMsg
1533  *
1534  * @return void
1535  *
1536  * ****************************************************************/
1537 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1538 {
1539    uint8_t ieIdx, ieIdx2;
1540    F1SetupRequest_t *f1SetupReq=NULLP;
1541
1542    if(f1apMsg != NULLP)
1543    {
1544       if(f1apMsg->choice.initiatingMessage != NULLP)
1545       {
1546          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1547          if(f1SetupReq->protocolIEs.list.array != NULLP)
1548          {
1549             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1550             {
1551                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1552                {
1553                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1554                   {
1555                      case ProtocolIE_ID_id_TransactionID:
1556                         break;
1557                      case ProtocolIE_ID_id_gNB_DU_ID:
1558                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1559                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1560                         break;
1561                      case ProtocolIE_ID_id_gNB_DU_Name:
1562                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1563                               strlen((char *)duCfgParam.duName));
1564                         break;
1565                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1566                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1567                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1568                         break;
1569                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1570                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1571                         break;
1572                      default:
1573                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1574                         break;
1575                   }
1576                }
1577             }
1578             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1579             {
1580                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1581             }
1582             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1583                   f1SetupReq->protocolIEs.list.size);
1584          }
1585          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1586       }
1587       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1588    }
1589 }
1590
1591 /*******************************************************************
1592  *
1593  * @brief Builds and Send the F1SetupRequest
1594  *
1595  * @details
1596  *
1597  *    Function : BuildAndSendF1SetupReq
1598  *
1599  * Functionality:Fills the F1SetupRequest
1600  *
1601  * @return ROK     - success
1602  *         RFAILED - failure
1603  *
1604  ******************************************************************/
1605 uint8_t BuildAndSendF1SetupReq()
1606 {
1607    uint8_t   ret, ieIdx, elementCnt;
1608    F1AP_PDU_t                 *f1apMsg = NULLP;
1609    F1SetupRequest_t           *f1SetupReq=NULLP;
1610    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1611    RRC_Version_t              *rrcVer=NULLP;
1612    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1613    ret= RFAILED;
1614
1615    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1616    do
1617    {
1618       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1619       if(f1apMsg == NULLP)
1620       {
1621          break;
1622       }
1623       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1624       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1625       if(f1apMsg->choice.initiatingMessage == NULLP)
1626       {
1627          break;
1628       }
1629       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1630       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1631       f1apMsg->choice.initiatingMessage->value.present = \
1632                                                          InitiatingMessage__value_PR_F1SetupRequest;
1633
1634       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1635
1636       elementCnt = 5;
1637
1638       f1SetupReq->protocolIEs.list.count = elementCnt;
1639       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t *);
1640
1641       /* Initialize the F1Setup members */
1642       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1643       if(f1SetupReq->protocolIEs.list.array == NULLP)
1644       {
1645          break;
1646       }
1647       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1648       {
1649          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1650                sizeof(F1SetupRequestIEs_t));
1651          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1652          {
1653             break;
1654          }
1655       }
1656
1657       ieIdx = 0;
1658       /*TransactionID*/
1659       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1660       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1661       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1662                                                                 F1SetupRequestIEs__value_PR_TransactionID;
1663       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1664                                                                               TRANS_ID;
1665
1666       /*DU ID*/
1667       ieIdx++;
1668       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1669       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1670       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1671                                                                  F1SetupRequestIEs__value_PR_GNB_DU_ID;
1672       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1673                                                                               sizeof(uint8_t);
1674
1675       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1676             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1677       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1678             NULLP)
1679       {
1680          break;
1681       }
1682
1683       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1684                                                                                 duCfgParam.duId;
1685       /* DU name IE is of type printableString_t which wireshark is unable to decode.
1686        * However this string is decoded successfully on online decoders.
1687        * Since this is an optional IE and the value received in it are not
1688        * used as of now, eliminating this IE for now to avoid wireshark error.
1689        */
1690       /*DU Name*/
1691       if(duCfgParam.duName != NULL)
1692       {
1693          ieIdx++;
1694          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1695          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1696          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1697          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size = strlen((char *)duCfgParam.duName);
1698          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf, \
1699                f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size);
1700          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf == NULLP)
1701          {
1702             break;
1703          }
1704          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,
1705                (char*)duCfgParam.duName);
1706       }
1707
1708       /*Served Cell list */
1709       ieIdx++;
1710       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1711                                                       ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1712       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1713       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1714                                                                  F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1715       duServedCell = &f1SetupReq->protocolIEs.list.\
1716                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1717       if(BuildServedCellList(duServedCell))
1718       {
1719          break;
1720       }
1721
1722       /*RRC Version*/
1723       ieIdx++;
1724       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1725                                                       ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1726       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1727       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1728                                                                  F1SetupRequestIEs__value_PR_RRC_Version;
1729       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1730       if(BuildRrcVer(rrcVer))
1731       {
1732          break;
1733       }
1734
1735       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1736
1737       /* Encode the F1SetupRequest type as APER */
1738       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1739       encBufSize = 0;
1740       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1741             encBuf);
1742
1743       /* Encode results */
1744       if(encRetVal.encoded == ENCODE_FAIL)
1745       {
1746          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1747                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1748          break;
1749       }
1750       else
1751       {
1752          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1753 #ifdef DEBUG_ASN_PRINT
1754          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1755          {
1756             printf("%x",encBuf[ieIdx]);
1757          }
1758 #endif
1759
1760
1761       }
1762
1763       /* Sending msg */
1764       if(sendF1APMsg() != ROK)
1765       {
1766          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1767          break;
1768       }
1769
1770       if(fillE2NodeComponentReqInfo(F1, duCfgParam.duId,  E2_NODE_COMPONENT_ADD, encBufSize, encBuf) !=ROK)
1771       {
1772          DU_LOG("\nERROR  -->  F1AP : Failed to add the e2 node in the list");
1773          break;
1774       }
1775
1776       ret=ROK;
1777       break;
1778    }while(true);
1779
1780    FreeF1SetupReq(f1apMsg);
1781
1782    return ret;
1783 }/* End of BuildAndSendF1SetupReq */
1784
1785 /*******************************************************************
1786  *
1787  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1788  *
1789  * @details
1790  *
1791  *    Function : freeCellsToModifyItem
1792  *
1793  *    Functionality: Deallocating memory of variables allocated in
1794  *                    BuildAndSendDUConfigUpdate function
1795  *
1796  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1797  *
1798  * @return ROK     - void
1799  *
1800  * ****************************************************************/
1801
1802 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1803 {
1804    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1805    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1806    SliceSupportItem_t *sliceSupportItem = NULLP;
1807
1808    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1809    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1810
1811    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1812            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1813    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1814          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1815
1816    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1817    {
1818       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1819       {
1820          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1821
1822          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1823
1824          if(servedPlmnItem->iE_Extensions != NULLP)
1825          {
1826             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1827             {
1828                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1829                {
1830                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1831                         list.array != NULLP)
1832                   {
1833                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1834                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1835                      {
1836                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1837                               list.array[sliceLstIdx] != NULLP)
1838                         {
1839
1840                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1841                                               SliceSupportList.list.array[sliceLstIdx];
1842
1843                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1844                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1845                            {
1846                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1847                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1848                            }
1849                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1850                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1851                         }
1852                      }
1853                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1854                            choice.SliceSupportList.list.array,\
1855                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1856                            extensionValue.choice.SliceSupportList.list.size);
1857                   }
1858                }
1859                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1860                {
1861                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1862                }
1863                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1864             }
1865             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1866          }
1867       }
1868       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1869       {
1870          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1871       }
1872       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1873          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1874    }
1875
1876    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1877    {
1878       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1879    }
1880    else
1881    {
1882       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
1883       {
1884          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1885          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1886       }
1887    }
1888    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1889          modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1890 }
1891
1892 /*******************************************************************
1893  *
1894  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1895  *
1896  * @details
1897  *
1898  *    Function : FreeDUConfigUpdate
1899  *
1900  *    Functionality: Deallocating memory of variables allocated in
1901  *                    BuildAndSendDUConfigUpdate function
1902  *
1903  * @params[in]  F1AP_PDU_t *f1apDuCfg
1904  *
1905  * @return ROK     - void
1906  *
1907  * ****************************************************************/
1908 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1909 {
1910    uint8_t  idx=0,ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1911    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1912    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1913    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1914    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1915    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1916    Cells_Status_ItemIEs_t *cellStatusItemIE;
1917
1918    if(f1apDuCfg != NULLP)
1919    {
1920       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1921       {
1922          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1923                        value.choice.GNBDUConfigurationUpdate;
1924          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1925          {
1926             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1927             {
1928                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1929                {
1930                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1931                   {
1932                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1933                         {
1934                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1935                                            value.choice.Served_Cells_To_Modify_List;
1936                            if(cellsToModify->list.array != NULLP)
1937                            {
1938                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1939                               {
1940                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1941                                  {
1942                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1943                                           Served_Cells_To_Modify_Item);
1944                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1945                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1946                                  }
1947                               }
1948                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1949                            }
1950                            break;
1951                         }
1952                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1953                         {
1954                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1955                                            value.choice.Served_Cells_To_Delete_List;
1956                            if(cellsToDelete->list.array != NULLP)
1957                            {
1958                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1959                               {
1960                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1961                                  {
1962                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1963                                           cellsToDelete->list.array[cellDeleteIdx]);
1964                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1965                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1966                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1967                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1968                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1969                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1970                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1971                                  }
1972                               }
1973                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1974                            }
1975
1976                            break;
1977                         }
1978                      case ProtocolIE_ID_id_gNB_DU_ID:
1979                         {
1980                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1981                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1982                            break;
1983                         }
1984                      case ProtocolIE_ID_id_Cells_Status_List:
1985                         {
1986                            for(idx = 0; idx < duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.count; idx++)
1987                            {
1988                               cellStatusItemIE = (Cells_Status_ItemIEs_t *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.array[idx];
1989                               DU_FREE(cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.nRCellIdentity.buf, cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.nRCellIdentity.size);
1990                               DU_FREE(cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.pLMN_Identity.buf, cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.pLMN_Identity.size);
1991                               DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.array[idx],sizeof(Cells_Status_ItemIEs_t));
1992                            }
1993                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.array,\
1994                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.size);
1995                         }
1996                   }
1997                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1998                         sizeof(GNBDUConfigurationUpdateIEs_t));
1999                }
2000             }
2001             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2002          }
2003          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2004       }
2005       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2006    }
2007 }
2008
2009 /*******************************************************************
2010  *
2011  * @brief Fills Served Plmns required in ServCellInfo IE
2012  *
2013  * @details
2014  *
2015  *    Function : fillServedPlmns
2016  *
2017  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2018  *
2019  * @params[in] Pointer to ServedPLMNs_List_t *
2020  *
2021  * @return ROK     - success
2022  *         RFAILED - failure
2023  *
2024  *****************************************************************/
2025
2026 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2027 {
2028    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2029
2030    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2031    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2032          array[arrayIdx]->pLMN_Identity.size);
2033    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2034    {
2035       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2036       return RFAILED;
2037    }
2038    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2039          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2040    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2041    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2042    {
2043       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2044       return RFAILED;
2045    }
2046
2047    ieListCnt=1;
2048    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2049    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2050    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2051          iE_Extensions->list.size);
2052    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2053    {
2054       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2055       return RFAILED;
2056    }
2057    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2058    {
2059       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2060             sizeof(ServedPLMNs_ItemExtIEs_t));
2061       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2062       {
2063          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2064          return RFAILED;
2065       }
2066    }
2067
2068    ieIdx = 0;
2069    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
2070    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2071    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2072    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2073    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2074    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2075       list.count = elementCnt;
2076    servedPlmn->list.array[arrayIdx]->\
2077       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2078       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2079    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2080          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2081          list.array,servedPlmn->list.array[arrayIdx]->\
2082          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2083    if(servedPlmn->list.array[arrayIdx]->\
2084          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2085          list.array == NULLP)
2086    {
2087       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2088       return RFAILED;
2089    }
2090
2091    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2092    {
2093       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2094       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2095       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2096       if(servedPlmn->list.array[arrayIdx]->\
2097       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2098       list.array[sliceLstIdx] == NULLP)
2099       {
2100          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2101          return RFAILED;
2102       }
2103
2104       servedPlmn->list.array[arrayIdx]->\
2105       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2106       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2107       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2108       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2109       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2110       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2111       sNSSAI.sST.size);
2112
2113       if(servedPlmn->list.array[arrayIdx]->\
2114       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2115       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2116       {
2117          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2118          return RFAILED;
2119       }
2120       servedPlmn->list.array[arrayIdx]->\
2121       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2122       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2123       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2124
2125       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2126       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2127       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2128       if(servedPlmn->list.array[arrayIdx]->\
2129       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2130       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2131       {
2132          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2133          return RFAILED;
2134       }
2135       servedPlmn->list.array[arrayIdx]->\
2136       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2137       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2138       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2139       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2140       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2141       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2142       list.array[sliceLstIdx]->sNSSAI.sD->size);
2143       if(servedPlmn->list.array[arrayIdx]->\
2144       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2145       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2146       {
2147          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2148          return RFAILED;
2149       }
2150       memcpy(servedPlmn->list.array[arrayIdx]->\
2151       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2152       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2153       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2154       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2155       list.array[sliceLstIdx]->sNSSAI.sD->size);
2156    }
2157    return ROK;
2158 }
2159
2160 /*******************************************************************
2161  *
2162  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2163  *
2164  * @details
2165  *
2166  *    Function : fillNrFddInfo
2167  *
2168  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2169  *
2170  * @params[in] FDD_Info_t *fDD
2171  *
2172  * @return ROK     - success
2173  *         RFAILED - failure
2174  *
2175  *****************************************************************/
2176
2177 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
2178 {
2179    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2180       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2181    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2182    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2183    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
2184          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2185    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2186    {
2187       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2188       return RFAILED;
2189    }
2190
2191    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2192       sizeof(FreqBandNrItem_t));
2193    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2194    {
2195       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2196       return RFAILED;
2197    }
2198
2199    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2200       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2201       freqBand[0].nrFreqBand;
2202    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2203    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2204       dlNrFreqInfo.nrArfcn;
2205    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2206    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2207    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2208    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2209    {
2210       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2211       return RFAILED;
2212    }
2213
2214    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
2215    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2216    {
2217       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2218       return RFAILED;
2219    }
2220
2221    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2222       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2223       freqBand[0].nrFreqBand;
2224    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2225
2226    /*Transmission Bandwidth*/
2227    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2228       f1Mode.mode.fdd.ulTxBw.nrScs;
2229    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2230       f1Mode.mode.fdd.ulTxBw.nrb;
2231    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2232       f1Mode.mode.fdd.dlTxBw.nrScs;
2233    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2234       f1Mode.mode.fdd.dlTxBw.nrb;
2235
2236    return ROK;
2237 }
2238
2239 /*******************************************************************
2240  *
2241  * @brief Fills ServCellInfo IE
2242  *
2243  * @details
2244  *
2245  *    Function : fillServedCellInfo
2246  *
2247  *    Functionality: Fills ServCellInfo
2248  *
2249  * @params[in] Pointer to Served_Cell_Information_t *
2250  *
2251  * @return ROK     - success
2252  *         RFAILED - failure
2253  *
2254  *****************************************************************/
2255
2256 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2257 {
2258    uint8_t ieIdx, ieListCnt;
2259
2260    /*nRCGI*/
2261    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2262    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2263          srvCellInfo->nRCGI.pLMN_Identity.size);
2264    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2265    {
2266       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2267       return RFAILED;
2268    }
2269    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2270          srvCellInfo->nRCGI.pLMN_Identity.buf);
2271    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2272    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2273          srvCellInfo->nRCGI.nRCellIdentity.size);
2274    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2275    {
2276       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2277       return RFAILED;
2278    }
2279
2280    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2281    /*nRPCI*/
2282    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2283
2284    /*servedPLMNs*/
2285    ieListCnt = 1;
2286    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2287    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2288    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2289    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2290    {
2291       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2292       return RFAILED;
2293    }
2294    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2295    {
2296       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2297       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2298       {
2299          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2300          return RFAILED;
2301       }
2302    }
2303    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2304    {
2305       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2306       return RFAILED;
2307    }
2308
2309 #ifndef NR_TDD
2310    /*nR Mode Info with FDD*/
2311    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2312    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2313    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2314    {
2315       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2316       return RFAILED;
2317    }
2318    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2319    {
2320        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2321       return RFAILED;
2322    }
2323 #else
2324    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2325    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2326    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2327    {
2328       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2329       return RFAILED;
2330    }
2331    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2332    {
2333       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2334       return RFAILED;
2335    }
2336 #endif
2337
2338    /*Measurement timing Config*/
2339    if(BuildMeasTimingConf(&srvCellInfo->measurementTimingConfiguration) != ROK)
2340       return RFAILED;
2341
2342    return ROK;
2343 }
2344
2345 /*******************************************************************
2346  *
2347  * @brief Fills ServCellToModItem IE
2348  *
2349  * @details
2350  *
2351  *    Function : fillServCellToModItem
2352  *
2353  *    Functionality: Fills ServCellToModItem IE
2354  *
2355  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2356  *
2357  * @return ROK     - success
2358  *         RFAILED - failure
2359  *
2360  *****************************************************************/
2361
2362 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2363 {
2364    /*pLMN_Identity*/
2365    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2366    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2367    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2368    {
2369       return RFAILED;
2370    }
2371    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2372          modifyItem->oldNRCGI.pLMN_Identity.buf);
2373
2374    /*nRCellIdentity*/
2375    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2376    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2377          modifyItem->oldNRCGI.nRCellIdentity.size);
2378    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2379    {
2380       return RFAILED;
2381    }
2382    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2383
2384    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2385       return RFAILED;
2386    else
2387       return ROK;
2388 }
2389
2390 /*******************************************************************
2391  *
2392  * @brief Builds ServCellToModList
2393  *
2394  * @details
2395  *
2396  *    Function : buildServCellToModList
2397  *
2398  *    Functionality: Builds the serv cell to Mod List
2399  *
2400  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2401  *
2402  * @return ROK     - success
2403  *         RFAILED - failure
2404  *
2405  *****************************************************************/
2406
2407 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2408 {
2409    uint8_t ieListCnt, ieIdx;
2410    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2411
2412    ieListCnt = 1;
2413    cellsToModify->list.count = ieListCnt;
2414    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2415    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2416    if(cellsToModify->list.array == NULLP)
2417    {
2418       return RFAILED;
2419    }
2420    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2421    {
2422       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2423       if(cellsToModify->list.array[ieIdx] == NULLP)
2424       {
2425          return RFAILED;
2426       }
2427    }
2428    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2429    cellsToModify->list.array[0]->criticality = Criticality_reject;
2430    cellsToModify->list.array[0]->value.present =\
2431       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2432    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2433
2434    if(fillServCellToModItem(modifyItem))
2435       return RFAILED;
2436    else
2437       return ROK;
2438 }
2439 /*******************************************************************
2440  *
2441  * @brief filling the DeleteItemList
2442  *
2443  * @details
2444  *
2445  *    Function : fillCellToDeleteItem
2446  *
2447  *    Functionality: Filling the DeleteItemIe
2448  *
2449  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2450  *
2451  * @return ROK     - success
2452  *         RFAILED - failure
2453  *
2454  *****************************************************************/
2455 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2456 {
2457    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2458
2459    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2460    deleteItemIe->criticality = Criticality_reject;
2461    deleteItemIe->value.present =\
2462    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2463    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2464
2465    /*pLMN_Identity*/
2466    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2467    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2468    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2469    {
2470       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2471       return RFAILED;
2472    }
2473    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2474          deleteItem->oldNRCGI.pLMN_Identity.buf);
2475
2476    /*nRCellIdentity*/
2477    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2478    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2479          deleteItem->oldNRCGI.nRCellIdentity.size);
2480    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2481    {
2482       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2483       return RFAILED;
2484    }
2485    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2486    return ROK;
2487 }
2488
2489 /*******************************************************************
2490  *
2491  * @brief Builds ServCellToDeleteList
2492  *
2493  * @details
2494  *
2495  *    Function : buildServCellToDeleteList
2496  *
2497  *    Functionality: Builds the serv cell to delete List
2498  *
2499  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2500  *
2501  * @return ROK     - success
2502  *         RFAILED - failure
2503  *
2504  *****************************************************************/
2505
2506 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2507 {
2508    uint8_t ieListCnt, arrIdx;
2509
2510    ieListCnt = 1;
2511    cellsToDelete->list.count = ieListCnt;
2512    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2513
2514    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2515    if(cellsToDelete->list.array == NULLP)
2516    {
2517       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2518       return RFAILED;
2519    }
2520
2521    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2522    {
2523       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2524       if(cellsToDelete->list.array[arrIdx] == NULLP)
2525       {
2526          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2527          return RFAILED;
2528       }
2529    }
2530
2531    arrIdx=0;
2532    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2533    {
2534       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2535       return RFAILED;
2536    }
2537    return ROK;
2538 }
2539
2540 /*******************************************************************
2541  *
2542  * @brief Builds CellsStatusList
2543  *
2544  * @details
2545  *
2546  *    Function : buildCellsStatusList
2547  *
2548  *    Functionality: Builds the Cell Status List
2549  *
2550  * @params[in] Pointer to Cells_Status_List_t *
2551  *
2552  * @return ROK     - success
2553  *         RFAILED - failure
2554  *
2555  *****************************************************************/
2556 uint8_t buildCellsStatusList(Cells_Status_List_t *cellStatusList)
2557 {
2558    uint8_t elementCnt = 0, idx = 0, ret = ROK;
2559    Cells_Status_ItemIEs_t *cellStatusItemIE;
2560
2561    elementCnt = 1;
2562    cellStatusList->list.count = elementCnt;
2563    cellStatusList->list.size = elementCnt * sizeof(Cells_Status_ItemIEs_t *);
2564    DU_ALLOC(cellStatusList->list.array, cellStatusList->list.size);
2565
2566    for(idx = 0; idx < elementCnt; idx++)
2567    {
2568       DU_ALLOC(cellStatusList->list.array[idx], sizeof(Cells_Status_ItemIEs_t));
2569       if(!cellStatusList->list.array[idx])
2570       {
2571          DU_LOG("ERROR  --> F1AP: buildCellsStatusList() memory allocation failure");
2572          return RFAILED;
2573       }
2574    }
2575    idx = 0;
2576    cellStatusItemIE = (Cells_Status_ItemIEs_t *)cellStatusList->list.array[idx];
2577    cellStatusItemIE->id = ProtocolIE_ID_id_Cells_Status_Item;
2578    cellStatusItemIE->criticality = Criticality_reject;
2579    cellStatusItemIE->value.present = Cells_Status_ItemIEs__value_PR_Cells_Status_Item;
2580    ret = BuildNrcgi(&cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI);
2581    if(ret == RFAILED)
2582    {
2583          DU_LOG("ERROR  --> F1AP: buildCellsStatusList() NRCGI failed");
2584          return RFAILED;
2585    }
2586    cellStatusItemIE->value.choice.Cells_Status_Item.service_status.service_state = Service_State_in_service;
2587    return ROK;
2588 }
2589
2590 /*******************************************************************
2591  *
2592  * @brief Builds and sends the DUConfigUpdate
2593  *
2594  * @details
2595  *
2596  *    Function : BuildAndSendDUConfigUpdate
2597  *
2598  *    Functionality: Constructs the DU Update message and sends
2599  *                   it to the CU through SCTP.
2600  *
2601  * @params[in] void **buf,Buffer to which encoded pattern is written into
2602  * @params[in] int *size,size of buffer
2603  *
2604  * @return ROK     - success
2605  *         RFAILED - failure
2606  *
2607  * ****************************************************************/
2608 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2609 {
2610    uint8_t ret =0, ieIdx=0, elementCnt=0;
2611    bool memAlloctionFailure = false;
2612    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2613    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2614    asn_enc_rval_t encRetVal;     /* Encoder return value */
2615
2616    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2617    ret= RFAILED;
2618
2619    while(true)
2620    {
2621       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2622       /* Allocate the memory for F1DuCfg */
2623       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2624       if(f1apDuCfg == NULLP)
2625       {
2626          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2627          break;
2628       }
2629
2630       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2631       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2632       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2633       {
2634          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2635          break;
2636       }
2637
2638       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2639                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2640       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2641       f1apDuCfg->choice.initiatingMessage->value.present = \
2642                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2643       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2644                     choice.GNBDUConfigurationUpdate;
2645       elementCnt = 4;
2646       duCfgUpdate->protocolIEs.list.count = elementCnt;
2647       duCfgUpdate->protocolIEs.list.size = \
2648                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2649
2650       /* Initialize the F1Setup members */
2651       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2652       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2653       {
2654          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2655          break;
2656       }
2657       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2658       {
2659          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2660          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2661          {
2662             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2663             memAlloctionFailure = true;
2664             break;
2665          }
2666       }
2667
2668       if(memAlloctionFailure == true)
2669       {
2670          break;
2671       }
2672       /*TransactionID*/
2673       ieIdx = 0;
2674       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2675       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2676       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2677       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2678       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2679
2680       ieIdx++;
2681       if(servCellAction == SERV_CELL_TO_MODIFY)
2682       {
2683          /*Served Cell to Modify */
2684          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2685          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2686          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2687          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2688          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2689          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2690                   Served_Cells_To_Modify_List))
2691          {
2692             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2693             break;
2694          }
2695       }
2696       else
2697       {
2698          /*Served Cell to Delete */
2699          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2700          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2701          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2702          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2703          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2704          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2705          Served_Cells_To_Delete_List)!=ROK)
2706          {
2707             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2708             break;
2709          }
2710
2711       }
2712       // TODO :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2713
2714       /*Cell Status List*/
2715       ieIdx++;
2716       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cells_Status_List;
2717       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2718       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2719            GNBDUConfigurationUpdateIEs__value_PR_Cells_Status_List;
2720       ret = buildCellsStatusList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List);
2721       if(ret == RFAILED)
2722       {
2723          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Cell Status List building failed");
2724          break;
2725       }
2726
2727       /*GNB DU ID */
2728       ieIdx++;
2729       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2730       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2731       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2732       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2733       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2734       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2735             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2736       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2737       {
2738          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2739          break;
2740       }
2741       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2742
2743       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2744
2745       /* Encode the DU Config Update type as APER */
2746       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2747       encBufSize = 0;
2748       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2749
2750       /* Checking encode results */
2751       if(encRetVal.encoded == ENCODE_FAIL)
2752       {
2753          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2754                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2755          break;
2756       }
2757       else
2758       {
2759          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2760 #ifdef DEBUG_ASN_PRINT
2761          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2762          {
2763             printf("%x",encBuf[ieIdx]);
2764          }
2765 #endif
2766       }
2767
2768       /* Sending msg */
2769       if(sendF1APMsg() != ROK)
2770       {
2771          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2772          break;
2773       }
2774
2775       if(fillE2NodeComponentReqInfo(F1, duCfgParam.duId, E2_NODE_COMPONENT_UPDATE, encBufSize, encBuf)!=ROK)
2776       {
2777          DU_LOG("\nERROR  -->  F1AP : Failed to update the e2 node in the list");
2778          break;
2779       }
2780
2781       ret = ROK;
2782       break;
2783    }
2784
2785    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2786    return ret;
2787 }
2788
2789
2790 /*******************************************************************
2791  *
2792  * @brief free the ULRRCMessageTransfer
2793  *
2794  * @details
2795  *
2796  *    Function : FreeULRRCMessageTransfer
2797  *
2798  *    Functionality: Deallocating the memory of variable allocated in
2799  *                      FreeULRRCMessageTransfer
2800  *
2801  * @params[in]
2802  *
2803  * @return ROK     - void
2804  *
2805  ******************************************************************/
2806 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2807 {
2808    uint8_t idx1;
2809    ULRRCMessageTransfer_t  *ulRRCMsg;
2810
2811    if(f1apMsg != NULLP)
2812    {
2813       if(f1apMsg->choice.initiatingMessage != NULLP)
2814       {
2815          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2816          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2817          {
2818             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2819             {
2820                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2821                {
2822                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2823                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2824                   {
2825                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2826                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2827                   }
2828                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2829                }
2830             }
2831             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2832          }
2833          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2834       }
2835       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2836    }
2837 }
2838 /*******************************************************************
2839  *
2840  * @brief Builds and sends the ULRRCMessageTransfer
2841  *
2842  * @details
2843  *
2844  *    Function : BuildAndSendULRRCMessageTransfer
2845  *
2846  *    Functionality: Constructs the UL RRC Message Transfer and sends
2847  *                   it to the CU through SCTP.
2848  *
2849  * @params[in]
2850  *
2851  * @return ROK     - success
2852  *         RFAILED - failure
2853  *
2854  * ****************************************************************/
2855 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  *ueCb, uint8_t lcId, \
2856       uint16_t msgLen, uint8_t *rrcMsg)
2857 {
2858    uint8_t                 elementCnt=0, idx1=0, idx=0;
2859    uint8_t                 ret = RFAILED;
2860    F1AP_PDU_t              *f1apMsg = NULLP;
2861    ULRRCMessageTransfer_t  *ulRRCMsg = NULLP;
2862    asn_enc_rval_t          encRetVal;        /* Encoder return value */
2863
2864    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2865
2866    while(true)
2867    {
2868       DU_LOG("\nINFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2869
2870       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2871       if(f1apMsg == NULLP)
2872       {
2873          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2874          break;
2875       }
2876       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2877       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2878       if(f1apMsg->choice.initiatingMessage == NULLP)
2879       {
2880          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2881          break;
2882       }
2883       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2884       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2885       f1apMsg->choice.initiatingMessage->value.present = \
2886                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2887       ulRRCMsg =
2888          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2889       elementCnt = 4;
2890       ulRRCMsg->protocolIEs.list.count = elementCnt;
2891       ulRRCMsg->protocolIEs.list.size = \
2892                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2893
2894       /* Initialize the F1Setup members */
2895       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2896       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2897       {
2898          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2899          break;
2900       }
2901       for(idx=0; idx<elementCnt; idx++)
2902       {
2903          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2904          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2905          {
2906             break;
2907          }
2908       }
2909
2910       idx1 = 0;
2911
2912       /*GNB CU UE F1AP ID*/
2913       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2914       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2915       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2916                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2917       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
2918
2919       /*GNB DU UE F1AP ID*/
2920       idx1++;
2921       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2922       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2923       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2924                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2925       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
2926
2927       /*SRBID*/
2928       idx1++;
2929       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2930       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2931       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2932                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2933       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2934
2935       /*RRCContainer*/
2936       idx1++;
2937       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2938       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2939       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2940                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2941       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2942       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2943             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2944       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2945       {
2946          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2947          break;
2948       }
2949       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2950       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2951             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2952
2953       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2954
2955       /* Encode the F1SetupRequest type as APER */
2956       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2957       encBufSize = 0;
2958       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2959             encBuf);
2960       /* Encode results */
2961       if(encRetVal.encoded == ENCODE_FAIL)
2962       {
2963          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2964                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2965          break;
2966       }
2967       else
2968       {
2969          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2970 #ifdef DEBUG_ASN_PRINT
2971          for(int i=0; i< encBufSize; i++)
2972          {
2973             printf("%x",encBuf[i]);
2974          }
2975 #endif
2976       }
2977
2978       /* Sending  msg  */
2979       if(sendF1APMsg()  !=      ROK)
2980       {
2981          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2982          break;
2983       }
2984       ret = ROK;
2985       break;
2986    }
2987    FreeULRRCMessageTransfer(f1apMsg);
2988
2989    return ret;
2990 }/* End of BuildAndSendULRRCMessageTransfer*/
2991
2992 /*******************************************************************
2993  *
2994  * @brief Builds tag config
2995  *
2996  * @details
2997  *
2998  *    Function : BuildTagConfig
2999  *
3000  *    Functionality: Builds tag config in MacCellGroupConfig
3001  *
3002  * @params[in] TAG_Config *tag_Config
3003  *
3004  * @return ROK     - success
3005  *         RFAILED - failure
3006  *
3007  * ****************************************************************/
3008 uint8_t BuildTagConfig(DuUeCb *ueCb, struct TAG_Config *tagConfig)
3009 {
3010    struct TAG_Config__tag_ToAddModList *tagList;
3011    uint8_t                     idx, elementCnt;
3012
3013    tagConfig->tag_ToReleaseList = NULLP;
3014    tagConfig->tag_ToAddModList = NULLP;
3015    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
3016    if(!tagConfig->tag_ToAddModList)
3017    {
3018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3019       return RFAILED;
3020    }
3021
3022    if(ueCb == NULLP)
3023       elementCnt = ODU_VALUE_ONE;
3024    else
3025       elementCnt = ueCb->duMacUeCfg.macCellGrpCfg.tagCfg.addModListCount;
3026
3027    tagList = tagConfig->tag_ToAddModList;
3028    tagList->list.count = elementCnt;
3029    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
3030
3031    tagList->list.array = NULLP;
3032    DU_ALLOC(tagList->list.array, tagList->list.size);
3033    if(!tagList->list.array)
3034    {
3035       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3036       return RFAILED;
3037    }
3038
3039    for(idx=0; idx<tagList->list.count; idx++)
3040    {
3041       tagList->list.array[idx] = NULLP;
3042       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
3043       if(!tagList->list.array[idx])
3044       {
3045          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3046          return RFAILED;
3047       }
3048    }
3049
3050    if(ueCb == NULLP)
3051    {
3052       idx = 0;
3053       tagList->list.array[idx]->tag_Id = TAG_ID;
3054       tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
3055    }
3056    else
3057    {
3058       for(idx=0; idx<tagList->list.count; idx++)
3059       {
3060          tagList->list.array[idx]->tag_Id = ueCb->duMacUeCfg.macCellGrpCfg.tagCfg.addModList[idx].tagId;
3061          tagList->list.array[idx]->timeAlignmentTimer = ueCb->duMacUeCfg.macCellGrpCfg.tagCfg.addModList[idx].timeAlignTimer;
3062       }
3063    }
3064
3065    return ROK;
3066 }
3067
3068 /*******************************************************************
3069  *
3070  * @brief Builds PHR Config
3071  *
3072  * @details
3073  *
3074  *    Function : BuildPhrConfig
3075  *
3076  *    Functionality: Builds phrConfig in MacCellGroupConfig
3077  *
3078  * @params[in] PHR Config *
3079  *
3080  * @return ROK     - success
3081  *         RFAILED - failure
3082  *
3083  * ****************************************************************/
3084 uint8_t BuildPhrConfig(DuUeCb *ueCb, struct MAC_CellGroupConfig__phr_Config *phrConfig)
3085 {
3086
3087    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3088    phrConfig->choice.setup = NULLP;
3089    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3090    if(!phrConfig->choice.setup)
3091    {
3092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3093       return RFAILED;
3094    }
3095
3096    if(ueCb == NULLP)
3097    {
3098       phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3099       phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3100       phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3101       phrConfig->choice.setup->multiplePHR              = false;
3102       phrConfig->choice.setup->dummy                    = false;
3103       phrConfig->choice.setup->phr_Type2OtherCell       = false;
3104       phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3105    }
3106    else
3107    {
3108       phrConfig->choice.setup->phr_PeriodicTimer        = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.periodicTimer;
3109       phrConfig->choice.setup->phr_ProhibitTimer        = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.prohibitTimer;
3110       phrConfig->choice.setup->phr_Tx_PowerFactorChange = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.txPowerFactor;
3111       phrConfig->choice.setup->multiplePHR              = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.multiplePHR;
3112       phrConfig->choice.setup->dummy                    = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.dummy;
3113       phrConfig->choice.setup->phr_Type2OtherCell       = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.phrType2OtherCell;
3114       phrConfig->choice.setup->phr_ModeOtherCG          = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.phrOtherCG;
3115    }
3116
3117    return ROK;
3118 }
3119
3120 /*******************************************************************
3121  *
3122  * @brief Builds BSR Config
3123  *
3124  * @details
3125  *
3126  *    Function : BuildBsrConfig
3127  *
3128  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3129  *
3130  * @params[in] BSR_Config *bsrConfig
3131  *
3132  * @return ROK     - success
3133  *         RFAILED - failure
3134  *
3135  * ****************************************************************/
3136 uint8_t BuildBsrConfig(DuUeCb *ueCb, struct BSR_Config *bsrConfig)
3137 {
3138    if(ueCb == NULLP)
3139    {
3140       bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3141       bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3142       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3143    }
3144    else
3145    {
3146       bsrConfig->periodicBSR_Timer = convertBsrPeriodicTmrValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.bsrTmrCfg.periodicTimer);
3147       bsrConfig->retxBSR_Timer     = convertBsrRetxTmrValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.bsrTmrCfg.retxTimer);
3148
3149       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3150       DU_ALLOC(bsrConfig->logicalChannelSR_DelayTimer, sizeof(long));
3151       if(bsrConfig->logicalChannelSR_DelayTimer == NULLP)
3152       {
3153          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildBsrConfig");
3154          return RFAILED;
3155       }
3156       *(bsrConfig->logicalChannelSR_DelayTimer) = convertLcSrDelayTmrValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.bsrTmrCfg.srDelayTimer);
3157    }
3158
3159    return ROK;
3160 }
3161
3162 /*******************************************************************
3163  *
3164  * @brief Builds scheduling request config
3165  *
3166  * @details
3167  *
3168  *    Function : BuildSchedulingReqConfig
3169  *
3170  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3171  *
3172  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3173  *
3174  * @return ROK     - success
3175  *         RFAILED - failure
3176  *
3177  * ****************************************************************/
3178 uint8_t BuildSchedulingReqConfig(DuUeCb *ueCb, struct SchedulingRequestConfig *schedulingRequestConfig)
3179 {
3180    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3181    uint8_t                     idx, elementCnt;
3182
3183    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3184    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3185          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3186    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3187    {
3188       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3189       return RFAILED;
3190    }
3191
3192    if(ueCb == NULLP)
3193       elementCnt = ODU_VALUE_ONE;
3194    else
3195       elementCnt = ueCb->duMacUeCfg.macCellGrpCfg.schReqCfg.addModListCount;
3196
3197    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3198    schReqList->list.count = elementCnt;
3199    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3200
3201    schReqList->list.array = NULLP;
3202    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3203    if(!schReqList->list.array)
3204    {
3205       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3206       return RFAILED;
3207    }
3208
3209    for(idx=0; idx<schReqList->list.count; idx++)
3210    {
3211       schReqList->list.array[idx] = NULLP;
3212       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3213       if(!schReqList->list.array[idx])
3214       {
3215          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3216          return RFAILED;
3217       }
3218    }
3219
3220    if(ueCb == NULLP)
3221    {
3222       idx = 0;
3223       schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3224
3225       schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3226       DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3227       if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3228       {
3229          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3230          return RFAILED;
3231       }
3232       *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3233       schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3234    }
3235    else
3236    {
3237       for(idx=0; idx<schReqList->list.count; idx++)
3238       {
3239          schReqList->list.array[idx]->schedulingRequestId = ueCb->duMacUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].schedReqId;
3240
3241          schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3242          DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3243          if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3244          {
3245             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3246             return RFAILED;
3247          }
3248          *(schReqList->list.array[idx]->sr_ProhibitTimer) = ueCb->duMacUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srProhibitTmr;
3249          schReqList->list.array[idx]->sr_TransMax = ueCb->duMacUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srTransMax;
3250       }
3251    }
3252
3253    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3254
3255    return ROK;
3256 }
3257
3258 /*******************************************************************
3259  *
3260  * @brief Builds RLC Configuration for AM mode
3261  *
3262  * @details
3263  *
3264  *    Function : BuildRlcConfigAm
3265  *
3266  *    Functionality:
3267  *       Builds AM mode RLC Config in BuildRlcBearerToAddModList
3268  *
3269  * @params[in] AmBearerCfg *amCfg
3270  *             RLC_Config_t  *rlcConfig
3271  *
3272  * @return ROK     - success
3273  *         RFAILED - failure
3274  *
3275  * ****************************************************************/
3276 uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig)
3277 {
3278    rlcConfig->choice.am = NULLP;
3279    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3280    if(!rlcConfig->choice.am)
3281    {
3282       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3283       return RFAILED;
3284    }
3285
3286    /* Fill AM UL configuration */
3287    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3288    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3289    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3290    {
3291       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3292       return RFAILED;
3293    }
3294
3295    /* Fill default AM UL configuration if input pointer to DU database is NULL */
3296    if(amCfg == NULLP)
3297    {
3298
3299       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN_12BIT; /*As per Spec 38.331, "Network configures only value size12 in SN-FieldLengthAM for SRB"*/
3300       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3301       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3302       rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3303       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3304    }
3305    else
3306    {
3307       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->dlAmCfg.snLenDl);
3308       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = covertPollRetxTmrValueToEnum(amCfg->dlAmCfg.pollRetxTmr);
3309       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = covertPollPduValueToEnum(amCfg->dlAmCfg.pollPdu);
3310       rlcConfig->choice.am->ul_AM_RLC.pollByte          = covertPollByteValueToEnum(amCfg->dlAmCfg.pollByte);
3311       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = covertMaxRetxValueToEnum(amCfg->dlAmCfg.maxRetxTh);
3312    }
3313
3314    /* Fill AM DL configuraion */
3315    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3316    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3317    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3318    {
3319       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3320       return RFAILED;
3321    }
3322
3323    /* Fill default AM DL configuration if input pointer to DU database is NULL */
3324    if(amCfg == NULLP)
3325    {
3326       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN_12BIT; /*As per Spec 38.331, "Network configures only value size12 in SN-FieldLengthAM for SRB"*/
3327       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3328       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3329    }
3330    else /* Fill AM configuration from DU database */
3331    {
3332       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->ulAmCfg.snLenUl);
3333       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = convertReasmblTmrValueToEnum(amCfg->ulAmCfg.reAssemTmr);
3334       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = convertProhibitTmrValueToEnum(amCfg->ulAmCfg.statProhTmr);
3335    }
3336    return ROK;
3337 }
3338
3339 /*******************************************************************
3340  *
3341  * @brief Builds RLC Config for UM Bidirection
3342  *
3343  * @details
3344  *
3345  *    Function : BuildRlcConfig UmBiDir
3346  *
3347  *    Functionality:
3348  *       Builds RLC Config for UM Bidirection in BuildRlcBearerToAddModList
3349  *
3350  * @params[in] UmBiDirBearerCfg *umBiDirCfg
3351  *             RLC_Config_t *rlcConfig
3352  *
3353  * @return ROK     - success
3354  *         RFAILED - failure
3355  *
3356  * ****************************************************************/
3357 uint8_t BuildRlcConfigUmBiDir(UmBiDirBearerCfg *umBiDirCfg, struct RLC_Config *rlcConfig)
3358 {
3359    rlcConfig->choice.um_Bi_Directional = NULLP;
3360    DU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
3361    if(rlcConfig->choice.um_Bi_Directional == NULLP)
3362    {
3363       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3364       return RFAILED;
3365    }
3366
3367    /* Fill UM Bidirectional UL configuration */
3368    rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
3369    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3370    if(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength == NULLP)
3371    {
3372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3373       return RFAILED;
3374    }
3375
3376    if(umBiDirCfg != NULLP)
3377    {
3378       *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->dlUmCfg.snLenDlUm);
3379    }
3380
3381    /* Fill UM Bidirectional DL configuration */
3382    rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
3383    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3384    if(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength == NULLP)
3385    {
3386       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3387       return RFAILED;
3388    }
3389
3390    if(umBiDirCfg != NULLP)
3391    {
3392       *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->ulUmCfg.snLenUlUm);
3393       rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umBiDirCfg->ulUmCfg.reAssemTmr);
3394    }
3395
3396    return ROK;
3397 }
3398
3399 /*******************************************************************
3400  *
3401  * @brief Builds RLC Config for UM Uni directional UL
3402  *
3403  * @details
3404  *
3405  *    Function : BuildRlcConfigUmUniDirUl
3406  *
3407  *    Functionality:
3408  *       Builds RLC Config for UM Unidirection UL in BuildRlcBearerToAddModList
3409  *
3410  * @params[in] UmUniDirDlBearerCfg *umUniDirDlCfg
3411  *             RLC_Config_t *rlcConfig
3412  *
3413  * @return ROK     - success
3414  *         RFAILED - failure
3415  *
3416  * ****************************************************************/
3417 uint8_t BuildRlcConfigUmUniDirUl(UmUniDirDlBearerCfg *umUniDirDlCfg, RLC_Config_t *rlcConfig)
3418 {
3419    rlcConfig->choice.um_Uni_Directional_UL = NULLP;
3420    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
3421    if(rlcConfig->choice.um_Uni_Directional_UL == NULLP)
3422    {
3423       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3424       return RFAILED;
3425    }
3426
3427    rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength = NULLP;
3428    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3429    if(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength == NULLP)
3430    {
3431       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3432       return RFAILED;
3433    }
3434
3435    if(umUniDirDlCfg != NULLP)
3436    {
3437       *(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirDlCfg->dlUmCfg.snLenDlUm);
3438    }
3439
3440    return ROK;
3441 }
3442
3443 /*******************************************************************
3444  *
3445  * @brief Builds RLC Config for UM Uni directional DL
3446  *
3447  * @details
3448  *
3449  *    Function : BuildRlcConfigUmUniDirDl
3450  *
3451  *    Functionality:
3452  *       Builds RLC Config for UM Unidirection DL in BuildRlcBearerToAddModList
3453  *
3454  * @params[in] UmUniDirUlBearerCfg *umUniDirUlCfg
3455  *             RLC_Config_t *rlcConfig
3456  *
3457  * @return ROK     - success
3458  *         RFAILED - failure
3459  *
3460  * ****************************************************************/
3461 uint8_t BuildRlcConfigUmUniDirDl(UmUniDirUlBearerCfg *umUniDirUlCfg, RLC_Config_t *rlcConfig)
3462 {
3463    rlcConfig->choice.um_Uni_Directional_DL = NULLP;
3464    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
3465    if(rlcConfig->choice.um_Uni_Directional_DL == NULLP)
3466    {
3467       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3468       return RFAILED;
3469    }
3470
3471    rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength = NULLP;
3472    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3473    if(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength == NULLP)
3474    {
3475       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3476       return RFAILED;
3477    }
3478
3479    if(umUniDirUlCfg != NULLP)
3480    {
3481       *(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirUlCfg->ulUmCfg.snLenUlUm);
3482       rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umUniDirUlCfg->ulUmCfg.reAssemTmr);
3483    }
3484
3485    return ROK;
3486 }
3487
3488 /*******************************************************************
3489  *
3490  * @brief Builds RLC Config
3491  *
3492  * @details
3493  *
3494  *    Function : BuildRlcConfig
3495  *
3496  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3497  *
3498  * @params[in] RLC_Config_t *rlcConfig
3499  *
3500  * @return ROK     - success
3501  *         RFAILED - failure
3502  *
3503  * ****************************************************************/
3504 uint8_t BuildRlcConfig(RlcBearerCfg *rbCfg, struct RLC_Config *rlcConfig)
3505 {
3506
3507    /* Fill default values if rbCfg is NULL */
3508    if(rbCfg == NULLP)
3509    {
3510       rlcConfig->present = RLC_Config_PR_am;
3511       BuildRlcConfigAm(NULLP, rlcConfig);
3512    }
3513    /* If RbCfg is present, fill RLC configurations from DU Database */
3514    else
3515    {
3516       rlcConfig->present = covertRlcModeFromIntEnumToRrcEnum(rbCfg->rlcMode);
3517       switch(rlcConfig->present)
3518       {
3519          case RLC_Config_PR_am:
3520             BuildRlcConfigAm(rbCfg->u.amCfg, rlcConfig);
3521             break;
3522          case RLC_Config_PR_um_Bi_Directional:
3523             BuildRlcConfigUmBiDir(rbCfg->u.umBiDirCfg, rlcConfig);
3524             break;
3525          case RLC_Config_PR_um_Uni_Directional_UL:
3526             BuildRlcConfigUmUniDirUl(rbCfg->u.umUniDirDlCfg, rlcConfig);
3527             break;
3528          case RLC_Config_PR_um_Uni_Directional_DL:
3529             BuildRlcConfigUmUniDirDl(rbCfg->u.umUniDirUlCfg, rlcConfig);
3530             break;
3531          case RLC_Config_PR_NOTHING:
3532          default:
3533             break;
3534       }
3535    }
3536
3537    return ROK;
3538 }
3539
3540 /*******************************************************************
3541  *
3542  * @brief Builds MAC LC Config
3543  *
3544  * @details
3545  *
3546  *    Function : BuildMacLCConfig
3547  *
3548  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3549  *
3550  * @params[in] struct LogicalChannelConfig macLcConfig
3551  *
3552  * @return ROK     - success
3553  *         RFAILED - failure
3554  *
3555  * ****************************************************************/
3556 uint8_t BuildMacLCConfig(LcCfg *lcCfgDb, struct LogicalChannelConfig *macLcConfig)
3557 {
3558    macLcConfig->ul_SpecificParameters = NULLP;
3559    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3560    if(!macLcConfig->ul_SpecificParameters)
3561    {
3562       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3563       return RFAILED;
3564    }
3565
3566    if(lcCfgDb == NULLP)
3567    {
3568       macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3569       macLcConfig->ul_SpecificParameters->prioritisedBitRate =  PRIORTISIED_BIT_RATE;
3570       macLcConfig->ul_SpecificParameters->bucketSizeDuration =  BUCKET_SIZE_DURATION;
3571    }
3572    else
3573    {
3574       macLcConfig->ul_SpecificParameters->priority = lcCfgDb->ulLcCfg.priority;
3575       macLcConfig->ul_SpecificParameters->prioritisedBitRate = lcCfgDb->ulLcCfg.pbr;
3576       macLcConfig->ul_SpecificParameters->bucketSizeDuration = lcCfgDb->ulLcCfg.bsd;
3577    }
3578
3579    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3580    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3581    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3582    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3583
3584    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3585    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3586    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3587    {
3588       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3589       return RFAILED;
3590    }
3591
3592    if(lcCfgDb == NULLP)
3593       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3594    else
3595       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = lcCfgDb->ulLcCfg.lcGroup;
3596
3597    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3598    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3599    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3600    {
3601       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3602       return RFAILED;
3603    }
3604
3605    if(lcCfgDb == NULLP)
3606       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3607    else
3608       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = lcCfgDb->ulLcCfg.schReqId;
3609
3610    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3611    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3612    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3613
3614    return ROK;
3615 }
3616
3617 /*******************************************************************
3618  *
3619  * @brief Builds RLC Bearer to Add/Mod list
3620  *
3621  * @details
3622  *
3623  *    Function :BuildRlcBearerToAddModList
3624  *
3625  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3626  *
3627  * @params[in] rlc_BearerToAddModList
3628  *
3629  * @return ROK     - success
3630  *         RFAILED - failure
3631  *
3632  * ****************************************************************/
3633 uint8_t BuildRlcBearerToAddModList(DuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3634 {
3635    uint8_t  idx = 0, lcIdx=0, macLcIdx = 0, elementCnt = 0;
3636
3637    if(ueCb == NULLP)
3638       elementCnt = 1;
3639    else if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
3640       elementCnt = ueCb->duRlcUeCfg.numLcs;
3641    else
3642    {
3643       for(lcIdx = 0; lcIdx<ueCb->duRlcUeCfg.numLcs; lcIdx++)
3644       {
3645          if(ueCb->duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.isLcAddModRspSent == false)
3646             elementCnt++;
3647       }
3648    }
3649    rlcBearerList->list.count = elementCnt;
3650    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3651
3652    rlcBearerList->list.array = NULLP;
3653    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3654    if(!rlcBearerList->list.array)
3655    {
3656       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3657       return RFAILED;
3658    }
3659
3660    for(idx=0; idx<rlcBearerList->list.count; idx++)
3661    {
3662       rlcBearerList->list.array[idx] = NULLP;
3663       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3664       if(!rlcBearerList->list.array[idx])
3665       {
3666          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3667          return RFAILED;
3668       }
3669    }
3670
3671    if(ueCb == NULLP)
3672    {
3673       idx=0;
3674       rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3675       DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3676       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3677       {
3678          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3679          return RFAILED;
3680       }
3681       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3682       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB1_LCID;
3683       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3684
3685       /* Fill RLC related Configurations for this Radio Bearer */
3686       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3687       DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3688       if(!rlcBearerList->list.array[idx]->rlc_Config)
3689       {
3690          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3691          return RFAILED;
3692       }
3693       if(BuildRlcConfig(NULLP, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3694       {
3695          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3696          return RFAILED;
3697       }
3698
3699       /* Fill MAC related configurations for this Radio Bearer */
3700       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3701       DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3702       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3703       {
3704          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3705          return RFAILED;
3706       }
3707       if(BuildMacLCConfig(NULLP, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3708       {
3709          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3710          return RFAILED;
3711       }
3712    }
3713    else
3714    {
3715       idx=0;
3716       for(lcIdx=0; lcIdx<ueCb->duRlcUeCfg.numLcs; lcIdx++)
3717       {
3718          if((ueCb->f1UeDb->actionType != UE_CTXT_CFG_QUERY) && (ueCb->duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.isLcAddModRspSent == true))
3719             continue;
3720
3721          /* Fill Logical channel identity */
3722          rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.lcId;
3723
3724          /* Fill Radio Bearer Id and type (DRB/SRB) for this logical channel */
3725          DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3726          if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3727          {
3728             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3729             return RFAILED;
3730          }
3731          rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3732                                                                       covertRbTypeFromIntEnumToRrcEnum(ueCb->duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.rbType);
3733          switch(rlcBearerList->list.array[idx]->servedRadioBearer->present)
3734          {
3735             case RLC_BearerConfig__servedRadioBearer_PR_srb_Identity:
3736                rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.rbId;
3737                break;
3738             case RLC_BearerConfig__servedRadioBearer_PR_drb_Identity:
3739                rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.rbId;
3740                break;
3741             case RLC_BearerConfig__servedRadioBearer_PR_NOTHING:
3742             default:
3743                break;
3744          }
3745          ueCb->duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.isLcAddModRspSent = true;
3746
3747          rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3748
3749          /* Fill RLC related Configurations for this Radio Bearer */
3750          rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3751          DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3752          if(!rlcBearerList->list.array[idx]->rlc_Config)
3753          {
3754             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3755             return RFAILED;
3756          }
3757          if(BuildRlcConfig(&ueCb->duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3758          {
3759             DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3760             return RFAILED;
3761          }
3762
3763          /* Fill MAC related configurations for this Radio Bearer */
3764          rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3765          DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3766          if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3767          {
3768             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3769             return RFAILED;
3770          }
3771          for(macLcIdx = 0; macLcIdx < ueCb->duMacUeCfg.numLcs; macLcIdx++)
3772          {
3773             if(ueCb->duMacUeCfg.lcCfgList[macLcIdx].lcConfig.lcId == ueCb->duRlcUeCfg.rlcLcCfg[lcIdx].rlcBearerCfg.lcId)
3774             {
3775                if(BuildMacLCConfig(&ueCb->duMacUeCfg.lcCfgList[macLcIdx].lcConfig, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3776                {
3777                   DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3778                   return RFAILED;
3779                }
3780                break;
3781             }
3782          }
3783
3784          idx++;
3785       }
3786    }
3787    return ROK;
3788 }
3789
3790 /*******************************************************************
3791  *
3792  * @brief Build Control resource set to add/modify list
3793  *
3794  * @details
3795  *
3796  *    Function : BuildControlRSetToAddModList
3797  *
3798  *    Functionality: Build Control resource set to add/modify list
3799  *
3800  * @params[in]
3801  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3802  *
3803  * @return ROK     - success
3804  *         RFAILED - failure
3805  *
3806  * ****************************************************************/
3807 uint8_t BuildControlRSetToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList)
3808 {
3809    uint8_t idx;
3810    uint8_t elementCnt;
3811    uint8_t numBytes, bitsUnused;
3812    struct ControlResourceSet *controlRSet;
3813    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3814    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3815
3816    if(pdcchCfg == NULLP)
3817       elementCnt = 1;
3818    else
3819       elementCnt = pdcchCfg->numCRsetToAddMod;
3820
3821    controlRSetList->list.count = elementCnt;
3822    controlRSetList->list.size = elementCnt * sizeof(struct ControlResourceSet *);
3823
3824    controlRSetList->list.array = NULLP;
3825    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3826    if(!controlRSetList->list.array)
3827    {
3828       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3829       return RFAILED;
3830    }
3831
3832    for(idx = 0; idx < elementCnt; idx++)
3833    {
3834       controlRSetList->list.array[idx] = NULLP;
3835       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3836       if(!controlRSetList->list.array[idx])
3837       {
3838          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3839          return RFAILED;
3840       }
3841    }
3842
3843    for(idx = 0; idx < elementCnt; idx++)
3844    {
3845       controlRSet = controlRSetList->list.array[idx];
3846
3847       if(pdcchCfg == NULLP)
3848          controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3849       else
3850          controlRSet->controlResourceSetId = pdcchCfg->cRSetToAddModList[idx].cRSetId;
3851
3852       /* size 6 bytes
3853        * 3 LSBs unsued
3854        * Bit string stored ff0000000000
3855        */
3856       numBytes = 6;
3857       bitsUnused = 3;
3858       controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3859
3860       controlRSet->frequencyDomainResources.buf = NULLP;
3861       DU_ALLOC(controlRSet->frequencyDomainResources.buf, controlRSet->frequencyDomainResources.size);
3862       if(!controlRSet->frequencyDomainResources.buf)
3863       {
3864          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3865          return RFAILED;
3866       }
3867
3868       memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3869
3870       if(pdcchCfg == NULLP)
3871       {
3872          coreset0EndPrb = CORESET0_END_PRB;
3873          coreset1StartPrb = coreset0EndPrb + 6;
3874          coreset1NumPrb = CORESET1_NUM_PRB;
3875          /* calculate the PRBs */
3876          fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3877          memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3878          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3879
3880          controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3881          controlRSet->cce_REG_MappingType.present = ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3882          controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3883       }
3884       else
3885       {
3886          memcpy(controlRSet->frequencyDomainResources.buf, pdcchCfg->cRSetToAddModList[idx].freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
3887          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3888          controlRSet->duration = pdcchCfg->cRSetToAddModList[idx].duration;
3889          controlRSet->cce_REG_MappingType.present = pdcchCfg->cRSetToAddModList[idx].cceRegMappingType;
3890          controlRSet->precoderGranularity = pdcchCfg->cRSetToAddModList[idx].precoderGranularity;
3891       }
3892       controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3893       controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3894       controlRSet->tci_PresentInDCI = NULLP;
3895
3896 #if 0
3897       uint8_t tciStateIdx;
3898
3899       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3900             sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3901       if(!controlRset->tci_StatesPDCCH_ToAddList)
3902       {
3903          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3904          return RFAILED;
3905       }
3906
3907       elementCnt = 1;
3908       controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3909       controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3910       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3911             controlRset->tci_StatesPDCCH_ToAddList->list.size)
3912          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3913          {
3914             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3915             return RFAILED;
3916          }
3917
3918       for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3919       {
3920          DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3921          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3922          {
3923             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3924             return RFAILED;
3925          }
3926       }
3927
3928       tciStateIdx = 0;
3929       /* TODO */
3930       *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3931
3932       DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3933       if(!controlRset->tci_PresentInDCI)
3934       {
3935          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3936          return RFAILED;
3937       }
3938       /* TODO */
3939       *(controlRset->tci_PresentInDCI);
3940 #endif
3941
3942       controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3943       DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3944       if(!controlRSet->pdcch_DMRS_ScramblingID)
3945       {
3946          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3947          return RFAILED;
3948       }
3949       if(pdcchCfg == NULLP)
3950          *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3951       else
3952          *(controlRSet->pdcch_DMRS_ScramblingID) = pdcchCfg->cRSetToAddModList[idx].dmrsScramblingId;
3953    }
3954    return ROK;
3955 } /* End BuildControlRSetToAddModList */
3956
3957 /*******************************************************************
3958  *
3959  * @brief build SlotOffset for SearchSpace
3960  *
3961  * @details
3962  *
3963  *    Function : BuildSearchSpcSlotOffset
3964  *
3965  *    Functionality: Build Slot Offset for search space to add/modify list
3966  *
3967  * @params[in] SearchSpace__monitoringSlotPeriodicityAndOffset *mSlotPeriodicityAndOffset
3968  *             uint16_t slotOffset
3969  * @return void
3970  *
3971  * ****************************************************************/
3972 void BuildSearchSpcSlotOffset(struct SearchSpace__monitoringSlotPeriodicityAndOffset *mSlotPeriodicityAndOffset,  uint16_t slotOffset)
3973 {
3974    switch(mSlotPeriodicityAndOffset->present)
3975    {
3976       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1:
3977          mSlotPeriodicityAndOffset->choice.sl1 = slotOffset;
3978          break;
3979       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl2:
3980          mSlotPeriodicityAndOffset->choice.sl2 = slotOffset;
3981          break;
3982       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl4:
3983          mSlotPeriodicityAndOffset->choice.sl4 = slotOffset;
3984          break;
3985       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl5:
3986          mSlotPeriodicityAndOffset->choice.sl5 = slotOffset;
3987          break;
3988       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl8:
3989          mSlotPeriodicityAndOffset->choice.sl8 = slotOffset;
3990          break;
3991       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl10:
3992          mSlotPeriodicityAndOffset->choice.sl10 = slotOffset;
3993          break;
3994       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl16:
3995          mSlotPeriodicityAndOffset->choice.sl16 = slotOffset;
3996          break;
3997       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl20:
3998          mSlotPeriodicityAndOffset->choice.sl20 = slotOffset;
3999          break;
4000       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl40:
4001          mSlotPeriodicityAndOffset->choice.sl40 = slotOffset;
4002          break;
4003       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl80:
4004          mSlotPeriodicityAndOffset->choice.sl80 = slotOffset;
4005          break;
4006       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl160:
4007          mSlotPeriodicityAndOffset->choice.sl160 = slotOffset;
4008          break;
4009       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl320:
4010          mSlotPeriodicityAndOffset->choice.sl320 = slotOffset;
4011          break;
4012       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl640:
4013          mSlotPeriodicityAndOffset->choice.sl640 = slotOffset;
4014          break;
4015       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1280:
4016          mSlotPeriodicityAndOffset->choice.sl1280 = slotOffset;
4017          break;
4018       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl2560:
4019          mSlotPeriodicityAndOffset->choice.sl2560 = slotOffset;
4020          break;
4021       default:
4022          break;
4023    }
4024 }
4025
4026
4027 /*******************************************************************
4028  *
4029  * @brief Build search space to add/modify list
4030  *
4031  * @details
4032  *
4033  *    Function : BuildSearchSpcToAddModList
4034  *
4035  *    Functionality: Build search space to add/modify list
4036  *
4037  * @params[in]
4038  * @return ROK     - success
4039  *         RFAILED - failure
4040  *
4041  * ****************************************************************/
4042 uint8_t BuildSearchSpcToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4043 {
4044    uint8_t idx;
4045    uint8_t numBytes;
4046    uint8_t byteIdx;
4047    uint8_t bitsUnused;
4048    uint8_t elementCnt;
4049    struct SearchSpace *searchSpc;
4050
4051    if(pdcchCfg == NULLP)
4052       elementCnt = 1;
4053    else
4054       elementCnt = pdcchCfg->numSearchSpcToAddMod;
4055
4056    searchSpcList->list.count = elementCnt;
4057    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
4058
4059    searchSpcList->list.array = NULLP;
4060    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
4061    if(!searchSpcList->list.array)
4062    {
4063       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
4064       return RFAILED;
4065    }
4066
4067    for(idx = 0; idx < elementCnt; idx++)
4068    {
4069       searchSpcList->list.array[idx] = NULLP;
4070       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
4071       if(!searchSpcList->list.array[idx])
4072       {
4073          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
4074          return RFAILED;
4075       }
4076    }
4077
4078    for(idx = 0; idx < elementCnt; idx++)
4079    {
4080       searchSpc = searchSpcList->list.array[idx];
4081
4082       if(pdcchCfg == NULLP)
4083          searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
4084       else
4085          searchSpc->searchSpaceId = pdcchCfg->searchSpcToAddModList[idx].searchSpaceId;
4086
4087       searchSpc->controlResourceSetId = NULLP;
4088       DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
4089       if(!searchSpc->controlResourceSetId)
4090       {
4091          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
4092          return RFAILED;
4093       }
4094       if(pdcchCfg == NULLP)
4095          *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
4096       else
4097          *(searchSpc->controlResourceSetId) = pdcchCfg->searchSpcToAddModList[idx].cRSetId;
4098
4099       searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
4100       DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4101       if(!searchSpc->monitoringSlotPeriodicityAndOffset)
4102       {
4103          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
4104          return RFAILED;
4105       }
4106       if(pdcchCfg == NULLP)
4107          searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
4108       else
4109       {
4110          searchSpc->monitoringSlotPeriodicityAndOffset->present = \
4111                      pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset.mSlotPeriodicity;
4112          BuildSearchSpcSlotOffset(searchSpc->monitoringSlotPeriodicityAndOffset, \
4113                      pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset.mSlotOffset);
4114       }
4115
4116       searchSpc->duration = NULLP;
4117       searchSpc->monitoringSymbolsWithinSlot = NULLP;
4118       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
4119       if(!searchSpc->monitoringSymbolsWithinSlot)
4120       {
4121          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
4122          return RFAILED;
4123       }
4124
4125       /* Values taken from reference logs :
4126        * size 2 bytes
4127        * 2 LSBs unsued
4128        * Bit string stores 8000
4129        */
4130       numBytes = 2;
4131       bitsUnused = 2;
4132       searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
4133       searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
4134       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
4135       if(!searchSpc->monitoringSymbolsWithinSlot->buf)
4136       {
4137          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
4138          return RFAILED;
4139       }
4140       if(pdcchCfg == NULLP)
4141       {
4142          byteIdx = 0;
4143          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
4144          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
4145       }
4146       else
4147          memcpy(searchSpc->monitoringSymbolsWithinSlot->buf, pdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot, numBytes);
4148       searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
4149
4150       searchSpc->nrofCandidates = NULLP;
4151       DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
4152       if(!searchSpc->nrofCandidates)
4153       {
4154          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
4155          return RFAILED;
4156       }
4157
4158       if(pdcchCfg == NULLP)
4159       {
4160          searchSpc->nrofCandidates->aggregationLevel1 = PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
4161          searchSpc->nrofCandidates->aggregationLevel2 = PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
4162          searchSpc->nrofCandidates->aggregationLevel4 = PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
4163          searchSpc->nrofCandidates->aggregationLevel8 = PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
4164          searchSpc->nrofCandidates->aggregationLevel16 = PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
4165       }
4166       else
4167       {
4168          searchSpc->nrofCandidates->aggregationLevel1 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1;
4169          searchSpc->nrofCandidates->aggregationLevel2 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2;
4170          searchSpc->nrofCandidates->aggregationLevel4 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4;
4171          searchSpc->nrofCandidates->aggregationLevel8 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8;
4172          searchSpc->nrofCandidates->aggregationLevel16 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16;
4173       }
4174
4175       searchSpc->searchSpaceType = NULLP;
4176       DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
4177       if(!searchSpc->searchSpaceType)
4178       {
4179          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
4180          return RFAILED;
4181       }
4182       if(pdcchCfg == NULLP)
4183          searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
4184       else
4185          searchSpc->searchSpaceType->present = pdcchCfg->searchSpcToAddModList[idx].searchSpaceType;
4186
4187       searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
4188       DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4189       if(!searchSpc->searchSpaceType->choice.ue_Specific)
4190       {
4191          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
4192          return RFAILED;
4193       }
4194       if(pdcchCfg == NULLP)
4195          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
4196       else
4197          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = pdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat;
4198    }
4199    return ROK;
4200 }/* End BuildSearchSpcToAddModList */
4201
4202 /*******************************************************************
4203  *
4204  * @brief Builds BWP DL dedicated PDCCH config
4205  *
4206  * @details
4207  *
4208  *    Function : BuildBWPDlDedPdcchCfg
4209  *
4210  *    Functionality: Builds BWP DL dedicated PDCCH config
4211  *
4212  * @params[in] struct PDCCH_Config *pdcchCfg
4213  *
4214  * @return ROK     - success
4215  *         RFAILED - failure
4216  *
4217  * ****************************************************************/
4218 uint8_t BuildBWPDlDedPdcchCfg(PdcchConfig *pdcchCfgDb, struct PDCCH_Config *pdcchCfg)
4219 {
4220    pdcchCfg->controlResourceSetToAddModList = NULLP;
4221    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
4222    if(!pdcchCfg->controlResourceSetToAddModList)
4223    {
4224       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
4225       return RFAILED;
4226    }
4227
4228    if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
4229    {
4230       DU_LOG("\nERROR  --> F1AP : Failed in BuildControlRSetToAddModList()");
4231       return RFAILED;
4232    }
4233
4234    pdcchCfg->controlResourceSetToReleaseList = NULLP;
4235
4236    pdcchCfg->searchSpacesToAddModList = NULLP;
4237    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
4238    if(!pdcchCfg->searchSpacesToAddModList)
4239    {
4240       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
4241       return RFAILED;
4242    }
4243
4244    if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
4245    {
4246       DU_LOG("\nERROR  --> F1AP : Failed in BuildSearchSpcToAddModList()");
4247       return RFAILED;
4248    }
4249
4250    pdcchCfg->searchSpacesToReleaseList = NULLP;
4251    pdcchCfg->downlinkPreemption = NULLP;
4252    pdcchCfg->tpc_PUSCH = NULLP;
4253    pdcchCfg->tpc_PUCCH = NULLP;
4254    pdcchCfg->tpc_SRS = NULLP;
4255
4256    return ROK;
4257 }
4258
4259 /*******************************************************************
4260  * @brief Builds DMRS DL PDSCH Mapping type A
4261  *
4262  * @details
4263  *
4264  *    Function : BuildDMRSDLPdschMapTypeA
4265  *
4266  *    Functionality: Builds DMRS DL PDSCH Mapping type A
4267  *
4268  * @params[in]
4269  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
4270  * @return ROK     - success
4271  *         RFAILED - failure
4272  *
4273  * ****************************************************************/
4274 uint8_t BuildDMRSDLPdschMapTypeA(PdschConfig *pdschCfg, struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg)
4275 {
4276    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
4277    dmrsDlCfg->choice.setup = NULLP;
4278    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
4279    if(!dmrsDlCfg->choice.setup)
4280    {
4281       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
4282       return RFAILED;
4283    }
4284
4285    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
4286    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4287    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4288    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
4289    {
4290       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
4291       return RFAILED;
4292    }
4293    if(pdschCfg == NULLP)
4294       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4295    else
4296       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = pdschCfg->dmrsDlCfgForPdschMapTypeA.addPos;
4297
4298    dmrsDlCfg->choice.setup->maxLength = NULLP;
4299    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
4300    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
4301    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
4302
4303    return ROK;
4304 }
4305
4306 /*******************************************************************
4307  *
4308  * @brief Builds TCI states to add/modify list
4309  *
4310  * @details
4311  *
4312  *    Function : BuildTCIStatesToAddModList
4313  *
4314  *    Functionality:Builds TCI states to add/modify list
4315  *
4316  * @params[in]
4317  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
4318  *
4319  * @return ROK     - success
4320  *         RFAILED - failure
4321  *
4322  * ****************************************************************/
4323 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
4324 {
4325    return ROK;
4326 }
4327
4328 /*******************************************************************
4329  *
4330  * @brief Builds PDSCH time domain allocation list
4331  *
4332  * @details
4333  *
4334  *    Function : BuildPdschTimeDomAllocList
4335  *
4336  *    Functionality: Builds PDSCH time domain allocation list
4337  *
4338  * @params[in]
4339  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4340  *
4341  * @return ROK     - success
4342  *         RFAILED - failure
4343  *
4344  * ****************************************************************/
4345 uint8_t BuildPdschTimeDomAllocList(PdschConfig *pdschCfg, struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4346 {
4347    uint8_t idx;
4348    uint8_t elementCnt;
4349    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
4350
4351    timeDomAllocList->present = PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
4352
4353    timeDomAllocList->choice.setup = NULLP;
4354    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4355    if(!timeDomAllocList->choice.setup)
4356    {
4357       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4358       return RFAILED;
4359    }
4360
4361 if(pdschCfg == NULLP)
4362    elementCnt = 2;
4363 else
4364 elementCnt = pdschCfg->numTimeDomRsrcAlloc;
4365    timeDomAllocList->choice.setup->list.count = elementCnt;
4366    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
4367
4368    timeDomAllocList->choice.setup->list.array = NULLP;
4369    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4370    if(!timeDomAllocList->choice.setup->list.array)
4371    {
4372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4373       return RFAILED;
4374    }
4375
4376    for(idx = 0; idx < elementCnt; idx++)
4377    {
4378       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4379       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
4380             sizeof(struct PDSCH_TimeDomainResourceAllocation));
4381       if(!timeDomAllocList->choice.setup->list.array[idx])
4382       {
4383          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4384          return RFAILED;
4385       }
4386    }
4387
4388    if(pdschCfg == NULLP)
4389    {
4390       idx = 0;
4391       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4392       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4393       if(!timeDomAlloc->k0)
4394       {
4395          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4396          return RFAILED;
4397       }
4398       *(timeDomAlloc->k0) = 0;
4399       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4400       timeDomAlloc->startSymbolAndLength = \
4401                                            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4402
4403       idx++;
4404       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4405       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4406       if(!timeDomAlloc->k0)
4407       {
4408          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4409          return RFAILED;
4410       }
4411       *(timeDomAlloc->k0) = 1;
4412       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4413       timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4414    }
4415    else
4416    {
4417       for(idx = 0; idx < elementCnt; idx++)
4418       {
4419          timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4420          if(pdschCfg->timeDomRsrcAllociList[idx].k0)
4421          {
4422             DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4423             if(!timeDomAlloc->k0)
4424             {
4425                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4426                return RFAILED;
4427             }
4428             *(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
4429          }
4430          timeDomAlloc->mappingType = pdschCfg->timeDomRsrcAllociList[idx].mappingType;
4431          timeDomAlloc->startSymbolAndLength = pdschCfg->timeDomRsrcAllociList[idx].startSymbolAndLength;
4432       }
4433    }
4434
4435    return ROK;
4436 }
4437
4438 /*******************************************************************
4439  *
4440  * @brief Builds PDSCH PRB Bundling type
4441  *
4442  * @details
4443  *
4444  *    Function : BuildPdschPrbBundlingType
4445  *
4446  *    Functionality: Builds PDSCH PRB Bundling type
4447  *
4448  * @params[in]
4449  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4450  *
4451  * @return ROK     - success
4452  *         RFAILED - failure
4453  *
4454  * ****************************************************************/
4455 uint8_t BuildPdschPrbBundlingType(PdschConfig *pdschCfg, struct PDSCH_Config__prb_BundlingType *prbBndlType)
4456 {
4457    if(pdschCfg == NULLP)
4458       prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4459    else
4460       prbBndlType->present = pdschCfg->bundlingType;
4461
4462    prbBndlType->choice.staticBundling = NULLP;
4463    DU_ALLOC(prbBndlType->choice.staticBundling, \
4464          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4465    if(!prbBndlType->choice.staticBundling)
4466    {
4467       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4468       return RFAILED;
4469    }
4470    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4471
4472    return ROK;
4473 }
4474
4475 /*******************************************************************
4476  *
4477  * @brief Builds BWP DL dedicated PDSCH config
4478  *
4479  * @details
4480  *
4481  *    Function : BuildBWPDlDedPdschCfg
4482  *
4483  *    Functionality: Builds BWP DL dedicated PDSCH config
4484  *
4485  * @params[in] struct PDSCH_Config *pdschCfg
4486  *
4487  * @return ROK     - success
4488  *         RFAILED - failure
4489  *
4490  * ****************************************************************/
4491 uint8_t BuildBWPDlDedPdschCfg(PdschConfig *pdschCfgDb, struct PDSCH_Config *pdschCfg)
4492 {
4493    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4494
4495    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4496    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4497    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4498    {
4499       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4500       return RFAILED;
4501    }
4502
4503    if(BuildDMRSDLPdschMapTypeA(pdschCfgDb, pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4504    {
4505       return RFAILED;
4506    }
4507
4508    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4509    pdschCfg->tci_StatesToAddModList = NULLP;
4510    pdschCfg->tci_StatesToReleaseList = NULLP;
4511    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4512 #if 0
4513    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4514    if(!pdschCfg->tci_StatesToAddModList)
4515    {
4516       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4517       return RFAILED;
4518    }
4519    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4520    {
4521       return RFAILED;
4522    }
4523 #endif
4524
4525 if(pdschCfgDb == NULLP)
4526    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4527 else
4528 pdschCfg->resourceAllocation = pdschCfgDb->resourceAllocType;
4529
4530    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4531    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4532    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4533    {
4534       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4535       return RFAILED;
4536    }
4537    if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4538    {
4539       return RFAILED;
4540    }
4541
4542    pdschCfg->pdsch_AggregationFactor = NULLP;
4543    pdschCfg->rateMatchPatternToAddModList = NULLP;
4544    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4545    pdschCfg->rateMatchPatternGroup1 = NULLP;
4546    pdschCfg->rateMatchPatternGroup2 = NULLP;
4547    if(pdschCfgDb == NULLP)
4548       pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4549    else
4550       pdschCfg->rbg_Size = pdschCfgDb->rbgSize;
4551    pdschCfg->mcs_Table = NULLP;
4552
4553    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4554    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4555    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4556    {
4557       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4558       return RFAILED;
4559    }
4560    if(pdschCfgDb == NULLP)
4561       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4562    else
4563       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = pdschCfgDb->numCodeWordsSchByDci;
4564
4565    if(BuildPdschPrbBundlingType(pdschCfgDb, &pdschCfg->prb_BundlingType) != ROK)
4566    {
4567       return RFAILED;
4568    }
4569
4570    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4571    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4572    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4573    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4574    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4575    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4576    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4577
4578    return ROK;
4579 }
4580
4581 /*******************************************************************
4582  *
4583  * @brief Builds intitial DL BWP
4584  * @details
4585  *
4586  *    Function : BuildInitialDlBWP
4587  *
4588  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4589  *
4590  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4591  *
4592  * @return ROK     - success
4593  *         RFAILED - failure
4594  *
4595  * ****************************************************************/
4596 uint8_t BuildInitialDlBWP(InitialDlBwp *initiDlBwp, BWP_DownlinkDedicated_t *dlBwp)
4597 {
4598    PdcchConfig *pdcchCfg = NULLP;
4599    PdschConfig *pdschCfg = NULLP;
4600
4601    if(initiDlBwp)
4602    {
4603       if(initiDlBwp->pdcchPresent)
4604          pdcchCfg = &initiDlBwp->pdcchCfg;
4605       if(initiDlBwp->pdschPresent)
4606          pdschCfg = &initiDlBwp->pdschCfg;
4607    }
4608
4609    dlBwp->pdcch_Config = NULLP;
4610    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4611    if(!dlBwp->pdcch_Config)
4612    {
4613       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4614       return RFAILED;
4615    }
4616    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4617
4618    dlBwp->pdcch_Config->choice.setup = NULLP;
4619    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4620    if(!dlBwp->pdcch_Config->choice.setup)
4621    {
4622       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4623       return RFAILED;
4624    }
4625    if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
4626    {
4627       return RFAILED;
4628    }
4629
4630    dlBwp->pdsch_Config = NULLP;
4631    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4632    if(!dlBwp->pdsch_Config)
4633    {
4634       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4635       return RFAILED;
4636    }
4637    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4638
4639    dlBwp->pdsch_Config->choice.setup = NULLP;
4640    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4641    if(!dlBwp->pdsch_Config->choice.setup)
4642    {
4643       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4644       return RFAILED;
4645    }
4646
4647    if(BuildBWPDlDedPdschCfg(pdschCfg, dlBwp->pdsch_Config->choice.setup) != ROK)
4648    {
4649       return RFAILED;
4650    }
4651
4652    dlBwp->sps_Config = NULLP;
4653    dlBwp->radioLinkMonitoringConfig = NULLP;
4654    return ROK;
4655 }
4656
4657 /*******************************************************************
4658  *
4659  * @brief Builds DMRS UL Pusch Mapping type A
4660  *
4661  * @details
4662  *
4663  *    Function : BuildDMRSULPuschMapTypeA
4664  *
4665  *    Functionality: Builds DMRS UL Pusch Mapping type A
4666  *
4667  * @params[in]
4668  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4669  * @return ROK     - success
4670  *         RFAILED - failure
4671  *
4672  * ****************************************************************/
4673 uint8_t BuildDMRSULPuschMapTypeA(DmrsUlCfg *ulDmrsCfgDb, struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg)
4674 {
4675    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4676    dmrsUlCfg->choice.setup= NULLP;
4677    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4678    if(!dmrsUlCfg->choice.setup)
4679    {
4680       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4681       return RFAILED;
4682    }
4683
4684    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4685    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4686    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4687    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4688    {
4689       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4690       return RFAILED;
4691    }
4692    if(ulDmrsCfgDb == NULLP)
4693       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4694    else
4695       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = ulDmrsCfgDb->addPos;
4696
4697    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4698    dmrsUlCfg->choice.setup->maxLength = NULLP;
4699    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4700    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4701    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4702    {
4703       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4704       return RFAILED;
4705    }
4706
4707    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4708    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4709          sizeof(long));
4710    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4711    {
4712       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4713       return RFAILED;
4714    }
4715    if(ulDmrsCfgDb == NULLP)
4716       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4717    else
4718       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = ulDmrsCfgDb->transPrecodDisabled.scramblingId0;
4719
4720    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4721    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4722    return ROK;
4723 }
4724
4725 /*******************************************************************
4726  *
4727  * @brief Build PUSCH time domain allocation list
4728  *
4729  * @details
4730  *
4731  *    Function : BuildPuschTimeDomAllocList
4732  *
4733  *    Functionality: Build PUSCH time domain allocation list
4734  *
4735  * @params[in]
4736  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4737  *
4738  * @return ROK     - success
4739  *         RFAILED - failure
4740  *
4741  * ****************************************************************/
4742 uint8_t BuildPuschTimeDomAllocList(PuschCfg *puschCfgDb, struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList)
4743 {
4744    uint8_t idx;
4745    uint8_t elementCnt;
4746    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4747
4748    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4749    timeDomAllocList->choice.setup = NULLP;
4750    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4751    if(!timeDomAllocList->choice.setup)
4752    {
4753       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4754       return RFAILED;
4755    }
4756
4757    if(puschCfgDb == NULLP)
4758       elementCnt = 2;
4759    else
4760       elementCnt = puschCfgDb->numTimeDomRsrcAlloc;
4761
4762    timeDomAllocList->choice.setup->list.count = elementCnt;
4763    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4764    timeDomAllocList->choice.setup->list.array = NULLP;
4765    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4766    if(!timeDomAllocList->choice.setup->list.array)
4767    {
4768       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4769       return RFAILED;
4770    }
4771
4772    for(idx = 0; idx < elementCnt; idx++)
4773    {
4774       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4775       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
4776       if(!timeDomAllocList->choice.setup->list.array[idx])
4777       {
4778          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4779          return RFAILED;
4780       }
4781    }
4782
4783    for(idx = 0; idx < elementCnt; idx++)
4784    {
4785       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4786       DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4787       if(!timeDomAlloc->k2)
4788       {
4789          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4790          return RFAILED;
4791       }
4792       if(puschCfgDb == NULLP)
4793       {
4794          if(idx == 0)
4795             *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4796          else if(idx == 1)
4797             *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4798
4799          timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4800          timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4801       }
4802       else
4803       {
4804          *(timeDomAlloc->k2) = puschCfgDb->timeDomRsrcAllocList[idx].k2;
4805          timeDomAlloc->mappingType = puschCfgDb->timeDomRsrcAllocList[idx].mappingType;
4806          timeDomAlloc->startSymbolAndLength = puschCfgDb->timeDomRsrcAllocList[idx].startSymbolAndLength;
4807       }
4808    }
4809
4810    return ROK;
4811 }
4812
4813 /*******************************************************************
4814  *
4815  * @brief Builds BWP UL dedicated PUSCH Config
4816  *
4817  * @details
4818  *
4819  *    Function : BuildBWPUlDedPuschCfg
4820  *
4821  *    Functionality:
4822  *      Builds BWP UL dedicated PUSCH Config
4823  *
4824  * @params[in] : PUSCH_Config_t *puschCfg
4825  *
4826  * @return ROK     - success
4827  *         RFAILED - failure
4828  *
4829  * ****************************************************************/
4830 uint8_t BuildBWPUlDedPuschCfg(PuschCfg *puschCfgDb, PUSCH_Config_t *puschCfg)
4831 {
4832    DmrsUlCfg *ulDmrsCfg = NULLP;
4833
4834    if(puschCfgDb)
4835       ulDmrsCfg = &puschCfgDb->dmrsUlCfgForPuschMapTypeA;
4836
4837    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4838    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4839    if(!puschCfg->dataScramblingIdentityPUSCH)
4840    {
4841       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4842       return RFAILED;
4843    }
4844    if(puschCfgDb == NULLP)
4845       *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4846    else
4847       *(puschCfg->dataScramblingIdentityPUSCH) = puschCfgDb->dataScramblingId;
4848
4849    puschCfg->txConfig = NULLP;
4850    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4851    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4852    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4853    {
4854       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4855       return RFAILED;
4856    }
4857
4858    if(BuildDMRSULPuschMapTypeA(ulDmrsCfg, puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4859    {
4860       return RFAILED;
4861    }
4862
4863    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4864    puschCfg->pusch_PowerControl = NULLP;
4865    puschCfg->frequencyHopping = NULLP;
4866    puschCfg->frequencyHoppingOffsetLists = NULLP;
4867
4868    if(puschCfgDb == NULLP)
4869       puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4870    else
4871       puschCfg->resourceAllocation = puschCfgDb->resourceAllocType;
4872
4873    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4874    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4875    if(!puschCfg->pusch_TimeDomainAllocationList)
4876    {
4877       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4878       return RFAILED;
4879    }
4880
4881    if(BuildPuschTimeDomAllocList(puschCfgDb, puschCfg->pusch_TimeDomainAllocationList) != ROK)
4882    {
4883       return RFAILED;
4884    }
4885
4886    puschCfg->pusch_AggregationFactor = NULLP;
4887    puschCfg->mcs_Table = NULLP;
4888    puschCfg->mcs_TableTransformPrecoder = NULLP;
4889    puschCfg->transformPrecoder = NULLP;
4890    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4891    if(!puschCfg->transformPrecoder)
4892    {
4893       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4894       return RFAILED;
4895    }
4896    if(puschCfgDb == NULLP)
4897       *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4898    else
4899       *(puschCfg->transformPrecoder) = puschCfgDb->transformPrecoder;
4900
4901    puschCfg->codebookSubset = NULLP;
4902    puschCfg->maxRank = NULLP;
4903    puschCfg->rbg_Size = NULLP;
4904    puschCfg->uci_OnPUSCH = NULLP;
4905    puschCfg->tp_pi2BPSK = NULLP;
4906
4907    return ROK;
4908 }
4909
4910 /*******************************************************************
4911  *
4912  * @brief Builds PUCCH resource set add/modify list
4913  *
4914  * @details
4915  *
4916  *    Function : BuildPucchRsrcSetAddModList
4917  *
4918  *    Functionality:
4919  *      Builds PUCCH resource set add/modify list
4920  *
4921  * @params[in] : PucchResrcSetCfg *rsrcSetCfgDb
4922  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4923  *
4924  * @return ROK     - success
4925  *         RFAILED - failure
4926  *
4927  * ****************************************************************/
4928 uint8_t BuildPucchRsrcSetAddModList(PucchResrcSetCfg *rsrcSetCfgDb, \
4929    struct PUCCH_Config__resourceSetToAddModList *resourceSetToAddModList)
4930 {
4931    uint8_t elementCnt = 0, rsrcSetIdx = 0, rsrcIdx = 0;
4932    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4933
4934    if(rsrcSetCfgDb == NULLP)
4935       elementCnt = 1;
4936    else
4937       elementCnt = rsrcSetCfgDb->resrcSetToAddModListCount;
4938
4939    resourceSetToAddModList->list.count = elementCnt;
4940    resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4941    DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
4942    if(resourceSetToAddModList->list.array == NULLP)
4943    {
4944       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4945       return RFAILED;
4946    }
4947    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4948    {
4949       DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4950       if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4951       {
4952          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4953          return RFAILED;
4954       }
4955    }
4956
4957    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4958    {
4959       rsrcSet = resourceSetToAddModList->list.array[rsrcSetIdx];
4960
4961       /* Resource set Id */
4962       if(rsrcSetCfgDb == NULLP)
4963          rsrcSet->pucch_ResourceSetId = 1;
4964       else
4965          rsrcSet->pucch_ResourceSetId = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcSetId;
4966
4967       /* Resource list of a resource set */
4968       if(rsrcSetCfgDb == NULLP)
4969          elementCnt = 1;
4970       else
4971          elementCnt = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcListCount;
4972       rsrcSet->resourceList.list.count = elementCnt;
4973       rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4974       DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4975       if(rsrcSet->resourceList.list.array == NULLP)
4976       {
4977          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4978          return RFAILED;
4979       }
4980
4981       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4982       {
4983          DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4984          if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4985          {
4986             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4987             return RFAILED;
4988          }
4989       }
4990       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4991       {
4992          if(rsrcSetCfgDb == NULLP)
4993             *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4994          else
4995             *(rsrcSet->resourceList.list.array[rsrcIdx]) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcList[rsrcIdx];
4996       }
4997
4998       /* Max payload size (minus 1) in a Resource set */
4999       rsrcSet->maxPayloadMinus1 = NULLP;
5000       if(rsrcSetCfgDb && rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize)
5001       {
5002          DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
5003          if(rsrcSet->maxPayloadMinus1 == NULLP)
5004          {
5005             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
5006             return RFAILED;
5007          }
5008          *(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
5009       }
5010    }
5011    return ROK;
5012 }
5013
5014 /*******************************************************************
5015  *
5016  * @brief Builds PUCCH resource add/modify list
5017  *
5018  * @details
5019  *
5020  *    Function : BuildPucchRsrcAdddModList
5021  *
5022  *    Functionality:
5023  *      Builds PUCCH resource add/modify list
5024  *
5025  * @params[in] : PucchResrcCfg *rsrcSetCfgDb
5026  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
5027  *
5028  * @return ROK     - success
5029  *         RFAILED - failure
5030  *
5031  * ****************************************************************/
5032 uint8_t BuildPucchRsrcAddModList(PucchResrcCfg *rsrcCfgDb, struct PUCCH_Config__resourceToAddModList  *resourceToAddModList)
5033 {
5034    uint8_t elementCnt = 0, rsrcIdx = 0;
5035    PUCCH_Resource_t *rsrc = NULLP;
5036
5037    if(rsrcCfgDb == NULLP)
5038       elementCnt = 1;
5039    else
5040       elementCnt = rsrcCfgDb->resrcToAddModListCount;
5041    resourceToAddModList->list.count = elementCnt;
5042    resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
5043    DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
5044    if(resourceToAddModList->list.array == NULLP)
5045    {
5046       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
5047       return RFAILED;
5048    }
5049    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
5050    {
5051       DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5052       if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
5053       {
5054          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
5055          return RFAILED;
5056       }
5057    }
5058
5059    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
5060    {
5061       rsrc = resourceToAddModList->list.array[rsrcIdx];
5062
5063       if(rsrcCfgDb == NULLP)
5064       {
5065          rsrc->pucch_ResourceId = 1;
5066          rsrc->startingPRB = 0;
5067          rsrc->format.present = PUCCH_Resource__format_PR_format1;
5068          DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5069          if(rsrc->format.choice.format1 == NULLP)
5070          {
5071             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
5072             return RFAILED;
5073          }
5074          rsrc->format.choice.format1->initialCyclicShift = 0;
5075          rsrc->format.choice.format1->nrofSymbols = 4;
5076          rsrc->format.choice.format1->startingSymbolIndex = 0;
5077          rsrc->format.choice.format1->timeDomainOCC = 0;
5078       }
5079       else
5080       {
5081          rsrc->pucch_ResourceId = rsrcCfgDb->resrcToAddModList[rsrcIdx].resrcId;
5082          rsrc->startingPRB = rsrcCfgDb->resrcToAddModList[rsrcIdx].startPrb;
5083          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop)
5084          {
5085             DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
5086             if(rsrc->intraSlotFrequencyHopping == NULLP)
5087             {
5088                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
5089                return RFAILED;
5090             }
5091             *(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
5092          }
5093          else
5094             rsrc->intraSlotFrequencyHopping = NULLP;
5095
5096          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop)
5097          {
5098             DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
5099             if(rsrc->secondHopPRB == NULLP)
5100             {
5101                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
5102                return RFAILED;
5103             }
5104             *(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
5105          }
5106          else
5107             rsrc->secondHopPRB = NULLP;
5108          rsrc->format.present = covertPucchFormatIntEnumToRrcEnum(rsrcCfgDb->resrcToAddModList[rsrcIdx].pucchFormat);
5109
5110          switch(rsrc->format.present)
5111          {
5112             case PUCCH_Resource__format_PR_NOTHING:
5113                break;
5114             case PUCCH_Resource__format_PR_format0:
5115                {
5116                   DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
5117                   if(rsrc->format.choice.format0 == NULLP)
5118                   {
5119                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
5120                      return RFAILED;
5121                   }
5122                   rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
5123                   rsrc->format.choice.format0->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->numSymbols;
5124                   rsrc->format.choice.format0->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->startSymbolIdx;
5125                   break;
5126                }
5127
5128             case PUCCH_Resource__format_PR_format1:
5129                {
5130                   DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5131                   if(rsrc->format.choice.format1 == NULLP)
5132                   {
5133                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
5134                      return RFAILED;
5135                   }
5136                   rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
5137                   rsrc->format.choice.format1->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->numSymbols;
5138                   rsrc->format.choice.format1->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->startSymbolIdx;
5139                   rsrc->format.choice.format1->timeDomainOCC = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->timeDomOCC;
5140                   break;
5141                }
5142
5143             case PUCCH_Resource__format_PR_format2:
5144                {
5145                   DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
5146                   if(rsrc->format.choice.format2 == NULLP)
5147                   {
5148                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
5149                      return RFAILED;
5150                   }
5151                   rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
5152                   rsrc->format.choice.format2->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numSymbols;
5153                   rsrc->format.choice.format2->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->startSymbolIdx;
5154                   break;
5155                }
5156
5157             case PUCCH_Resource__format_PR_format3:
5158                {
5159                   DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
5160                   if(rsrc->format.choice.format3 == NULLP)
5161                   {
5162                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
5163                      return RFAILED;
5164                   }
5165                   rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
5166                   rsrc->format.choice.format3->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numSymbols;
5167                   rsrc->format.choice.format3->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->startSymbolIdx;
5168                   break;
5169                }
5170
5171             case PUCCH_Resource__format_PR_format4:
5172                {
5173                   DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
5174                   if(rsrc->format.choice.format4 == NULLP)
5175                   {
5176                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
5177                      return RFAILED;
5178                   }
5179                   rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
5180                   rsrc->format.choice.format4->occ_Length = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occLen;
5181                   rsrc->format.choice.format4->occ_Index = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occIdx;
5182                   rsrc->format.choice.format4->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->startSymbolIdx;
5183                   break;
5184                }
5185          }
5186       }
5187    }
5188    return ROK;
5189 }
5190
5191 /*******************************************************************
5192  *
5193  * @brief Builds PUCCH format  config
5194  *
5195  * @details
5196  *
5197  *    Function : BuildPucchFormat
5198  *
5199  *    Functionality: Builds PUCCH format  config
5200  *
5201  * @params[in] : PucchFormatCfg *formatDb
5202  *               PUCCH_FormatConfig_t *format
5203  *
5204  * @return ROK     - success
5205  *         RFAILED - failure
5206  *
5207  * ****************************************************************/
5208 uint8_t BuildPucchFormat(PucchFormatCfg *formatDb, PUCCH_FormatConfig_t *format)
5209 {
5210    /* Inter Slot Fequency hopping */
5211    format->interslotFrequencyHopping = NULLP;
5212    if((formatDb != NULLP) && (formatDb->interSlotFreqHop == true))
5213    {
5214       DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
5215       if(format->interslotFrequencyHopping)
5216       {
5217          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
5218          return RFAILED;
5219       }
5220       *(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
5221    }
5222
5223    /* Additional DMRS */
5224    format->additionalDMRS = NULLP;
5225    if((formatDb != NULLP) && (formatDb->addDmrs == true))
5226    {
5227       DU_ALLOC(format->additionalDMRS, sizeof(long));
5228       if(format->additionalDMRS)
5229       {
5230          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
5231          return RFAILED;
5232       }
5233       *(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
5234    }
5235
5236     /* Maximum code rate */
5237    format->maxCodeRate = NULLP;
5238    if((formatDb != NULLP) && (formatDb->maxCodeRate != 0))
5239    {
5240       DU_ALLOC(format->maxCodeRate, sizeof(long));
5241       if(format->maxCodeRate)
5242       {
5243          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
5244          return RFAILED;
5245       }
5246       *(format->maxCodeRate) = formatDb->maxCodeRate;
5247    }
5248
5249    /* Number of slots */
5250    format->nrofSlots = NULLP;
5251    if((formatDb == NULLP) || ((formatDb != NULLP) && (formatDb->numSlots != 0)))
5252    {
5253       DU_ALLOC(format->nrofSlots, sizeof(long));
5254       if(format->nrofSlots == NULLP)
5255       {
5256          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
5257          return RFAILED;
5258       }
5259       if(formatDb == NULLP)
5260          *(format->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
5261       else
5262          *(format->nrofSlots) = formatDb->numSlots;
5263    }
5264
5265    /* Pi2BPSK*/
5266    format->pi2BPSK = NULLP;
5267    if((formatDb != NULLP) && (formatDb->pi2BPSK == true))
5268    {
5269       DU_ALLOC(format->pi2BPSK, sizeof(long));
5270       if(format->pi2BPSK)
5271       {
5272          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
5273          return RFAILED;
5274       }
5275       *(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
5276    }
5277
5278    /* Simultaneous HARQ ACK and CSI */
5279    format->simultaneousHARQ_ACK_CSI = NULLP;
5280    if((formatDb != NULLP) && (formatDb->harqAckCSI == true))
5281    {
5282       DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
5283       if(format->simultaneousHARQ_ACK_CSI)
5284       {
5285          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
5286          return RFAILED;
5287       }
5288       *(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
5289    }
5290
5291    return ROK;
5292 }
5293
5294
5295 /*******************************************************************
5296  *
5297  * @brief Builds PUCCH scheduling request list
5298  *
5299  * @details
5300  *
5301  *    Function : BuildPucchSchReqAddModList
5302  *
5303  *    Functionality:
5304  *      Builds PUCCH scheduling request list
5305  *
5306  * @params[in] : PucchSchedReqCfg *schReqDb
5307  *               struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList
5308  *
5309  * @return ROK     - success
5310  *         RFAILED - failure
5311  *
5312  * ****************************************************************/
5313 uint8_t BuildPucchSchReqAddModList(PucchSchedReqCfg *schReqDb, \
5314    struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList)
5315 {
5316    uint8_t elementCnt = 0, schReqIdx = 0;
5317    SchedulingRequestResourceConfig_t *schReqRsrc;
5318
5319    elementCnt = schReqDb->schedAddModListCount;
5320    schReqRsrcToAddModList->list.count = elementCnt;
5321    schReqRsrcToAddModList->list.size = elementCnt *sizeof(struct SchedulingRequestResourceConfig *);
5322
5323    schReqRsrcToAddModList->list.array = NULLP;
5324    DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
5325    if(schReqRsrcToAddModList->list.array == NULLP)
5326    {
5327       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5328       return RFAILED;
5329    }
5330
5331    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
5332    {
5333       DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
5334       if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
5335       {
5336          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5337          return RFAILED;
5338       }
5339    }
5340
5341    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
5342    {
5343       schReqRsrc = schReqRsrcToAddModList->list.array[schReqIdx];
5344       schReqRsrc->schedulingRequestResourceId = schReqDb->schedAddModList[schReqIdx].resrcId;
5345       schReqRsrc->schedulingRequestID = schReqDb->schedAddModList[schReqIdx].requestId;
5346
5347       if(schReqDb->schedAddModList[schReqIdx].periodicity)
5348       {
5349          schReqRsrc->periodicityAndOffset = NULLP;
5350          DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
5351          if(schReqRsrc->periodicityAndOffset == NULLP)
5352          {
5353             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5354             return RFAILED;
5355          }
5356
5357          schReqRsrc->periodicityAndOffset->present = schReqDb->schedAddModList[schReqIdx].periodicity;
5358          switch(schReqRsrc->periodicityAndOffset->present)
5359          {
5360             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_NOTHING:
5361                break;
5362             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
5363                schReqRsrc->periodicityAndOffset->choice.sym2 = schReqDb->schedAddModList[schReqIdx].offset;
5364                break;
5365             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
5366                schReqRsrc->periodicityAndOffset->choice.sym6or7 = schReqDb->schedAddModList[schReqIdx].offset;
5367                break;
5368             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
5369                schReqRsrc->periodicityAndOffset->choice.sl1 = schReqDb->schedAddModList[schReqIdx].offset;
5370                break;
5371             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
5372                schReqRsrc->periodicityAndOffset->choice.sl2 = schReqDb->schedAddModList[schReqIdx].offset;
5373                break;
5374             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
5375                schReqRsrc->periodicityAndOffset->choice.sl4 = schReqDb->schedAddModList[schReqIdx].offset;
5376                break;
5377             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
5378                schReqRsrc->periodicityAndOffset->choice.sl5 = schReqDb->schedAddModList[schReqIdx].offset;
5379                break;
5380             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
5381                schReqRsrc->periodicityAndOffset->choice.sl8 = schReqDb->schedAddModList[schReqIdx].offset;
5382                break;
5383             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
5384                schReqRsrc->periodicityAndOffset->choice.sl10 = schReqDb->schedAddModList[schReqIdx].offset;
5385                break;
5386             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
5387                schReqRsrc->periodicityAndOffset->choice.sl16 = schReqDb->schedAddModList[schReqIdx].offset;
5388                break;
5389             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
5390                schReqRsrc->periodicityAndOffset->choice.sl20 = schReqDb->schedAddModList[schReqIdx].offset;
5391                break;
5392             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
5393                schReqRsrc->periodicityAndOffset->choice.sl40 = schReqDb->schedAddModList[schReqIdx].offset;
5394                break;
5395             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
5396                schReqRsrc->periodicityAndOffset->choice.sl80 = schReqDb->schedAddModList[schReqIdx].offset;
5397                break;
5398             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
5399                schReqRsrc->periodicityAndOffset->choice.sl160 = schReqDb->schedAddModList[schReqIdx].offset;
5400                break;
5401             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
5402                schReqRsrc->periodicityAndOffset->choice.sl320 = schReqDb->schedAddModList[schReqIdx].offset;
5403                break;
5404             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
5405                schReqRsrc->periodicityAndOffset->choice.sl640 = schReqDb->schedAddModList[schReqIdx].offset;
5406                break;
5407          }
5408       }
5409
5410       if(schReqDb->schedAddModList[schReqIdx].resrc)
5411       {
5412          schReqRsrc->resource = NULLP;
5413          DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
5414          if(schReqRsrc->resource == NULLP)
5415          {
5416             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5417             return RFAILED;
5418          }
5419          *(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
5420
5421       }
5422    }
5423    return ROK;
5424 }
5425
5426 /*******************************************************************
5427  *
5428  * @brief Builds PUCCH multi csi resource list
5429  *
5430  * @details
5431  *
5432  *    Function : BuildPucchMultiCsiRsrcList
5433  *
5434  *    Functionality:
5435  *      Builds PUCCH multi csi resource list
5436  *
5437  * @params[in] : PucchMultiCsiCfg *multiCsiDb
5438  *               struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList
5439  *
5440  * @return ROK     - success
5441  *         RFAILED - failure
5442  *
5443  * ****************************************************************/
5444 uint8_t BuildPucchMultiCsiRsrcList(PucchMultiCsiCfg *multiCsiDb, struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList)
5445 {
5446    uint8_t elementCnt = 0, rsrcIdx = 0;
5447
5448    elementCnt = multiCsiDb->multiCsiResrcListCount;
5449    multiCsiRsrcList->list.count = elementCnt;
5450    multiCsiRsrcList->list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
5451    multiCsiRsrcList->list.array = NULLP;
5452    DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
5453    if(multiCsiRsrcList->list.array == NULLP)
5454    {
5455       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5456       return RFAILED;
5457    }
5458
5459    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5460    {
5461       DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5462       if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
5463       {
5464          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5465          return RFAILED;
5466       }
5467    }
5468
5469    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5470    {
5471       *(multiCsiRsrcList->list.array[rsrcIdx]) = multiCsiDb->multiCsiResrcList[rsrcIdx];
5472    }
5473    return ROK;
5474 }
5475
5476 /*******************************************************************
5477  *
5478  * @brief Builds DL data -to- Ul Ack list
5479  *
5480  * @details
5481  *
5482  *    Function : BuildDlDataToUlAckList
5483  *
5484  *    Functionality: Builds DL data -to- Ul Ack list
5485  *
5486  * @params[in] : PucchDlDataToUlAck *dlDataToUlAckDb
5487  *               struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList
5488  *
5489  * @return ROK     - success
5490  *         RFAILED - failure
5491  *
5492  * ****************************************************************/
5493 uint8_t BuildDlDataToUlAckList(PucchDlDataToUlAck *dlDataToUlAckDb, struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList)
5494 {
5495    uint8_t elementCnt = 0, arrIdx = 0;
5496
5497    if(dlDataToUlAckDb == NULLP)
5498       elementCnt = 2;
5499    else
5500       elementCnt = dlDataToUlAckDb->dlDataToUlAckListCount;
5501
5502    dlDataToUlACKList->list.count = elementCnt;
5503    dlDataToUlACKList->list.size = elementCnt * sizeof(long *);
5504    DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
5505    if(dlDataToUlACKList->list.array == NULLP)
5506    {
5507       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5508       return RFAILED;
5509    }
5510
5511    for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5512    {
5513       DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
5514       if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
5515       {
5516          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5517          return RFAILED;
5518       }
5519    }
5520
5521    if(dlDataToUlAckDb == NULLP)
5522    {
5523       arrIdx = 0;
5524       *(dlDataToUlACKList->list.array[arrIdx++]) = 1;
5525       *(dlDataToUlACKList->list.array[arrIdx]) = 2;
5526    }
5527    else
5528    {
5529       for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5530       {
5531          *(dlDataToUlACKList->list.array[arrIdx]) = dlDataToUlAckDb->dlDataToUlAckList[arrIdx];
5532       }
5533    }
5534    return ROK;
5535 }
5536
5537 /*******************************************************************
5538  *
5539  * @brief Builds BWP UL dedicated PUCCH Config
5540  *
5541  * @details
5542  *
5543  *    Function : BuildBWPUlDedPucchCfg
5544  *
5545  *    Functionality:
5546  *      Builds BWP UL dedicated PUCCH Config
5547  *
5548  * @params[in] : PUCCH_Config_t *pucchCfg
5549  *
5550  * @return ROK     - success
5551  *         RFAILED - failure
5552  *
5553  * ****************************************************************/
5554 uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg)
5555 {
5556    PucchResrcSetCfg *rsrcSetCfgDb = NULLP;
5557    PucchResrcCfg *rsrcCfgDb = NULLP;
5558    PucchFormatCfg *format1Db = NULLP;
5559    PucchFormatCfg *format2Db = NULLP;
5560    PucchFormatCfg *format3Db = NULLP;
5561    PucchFormatCfg *format4Db = NULLP;
5562    PucchSchedReqCfg *schReqDb = NULLP;
5563    PucchMultiCsiCfg  *multiCsiDb = NULLP;
5564    PucchDlDataToUlAck *dlDataToUlAckDb = NULLP;
5565
5566    if(pucchCfgDb)
5567    {
5568       rsrcSetCfgDb = pucchCfgDb->resrcSet;
5569       rsrcCfgDb = pucchCfgDb->resrc;
5570       format1Db = pucchCfgDb->format1;
5571       format2Db = pucchCfgDb->format2;
5572       format3Db = pucchCfgDb->format3;
5573       format4Db = pucchCfgDb->format4;
5574       schReqDb = pucchCfgDb->schedReq;
5575       multiCsiDb = pucchCfgDb->multiCsiCfg;
5576       dlDataToUlAckDb = pucchCfgDb->dlDataToUlAck;
5577    }
5578
5579    /* RESOURCE SET */
5580    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5581    if(pucchCfg->resourceSetToAddModList == NULL)
5582    {
5583       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5584       return RFAILED;
5585    }
5586
5587    if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
5588    {
5589       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5590       return RFAILED;
5591    }
5592
5593    /* PUCCH RESOURCE */
5594    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5595    if(pucchCfg->resourceToAddModList == NULLP)
5596    {
5597       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5598       return RFAILED;
5599    }
5600
5601    if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
5602    {
5603       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5604       return RFAILED;
5605    }
5606
5607    /* PUCCH Format 1 */
5608    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5609    if(pucchCfg->format1 == NULLP)
5610    {
5611       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5612       return RFAILED;
5613    }
5614
5615    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
5616    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5617    if(pucchCfg->format1->choice.setup == NULLP)
5618    {
5619       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5620       return RFAILED;
5621    }
5622
5623    if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
5624    {
5625       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5626       return RFAILED;
5627    }
5628
5629    /* PUCCH Format 2 */
5630    if(format2Db)
5631    {
5632       DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
5633       if(pucchCfg->format2 == NULLP)
5634       {
5635          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5636          return RFAILED;
5637       }
5638
5639       pucchCfg->format2->present = PUCCH_Config__format2_PR_setup;
5640       DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
5641       if(pucchCfg->format2->choice.setup == NULLP)
5642       {
5643          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5644          return RFAILED;
5645       }
5646
5647       if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
5648       {
5649          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5650          return RFAILED;
5651       }
5652    }
5653
5654    /* PUCCH Format 3 */
5655    if(format3Db)
5656    {
5657       DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
5658       if(pucchCfg->format3 == NULLP)
5659       {
5660          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5661          return RFAILED;
5662       }
5663
5664       pucchCfg->format3->present = PUCCH_Config__format3_PR_setup;
5665       DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
5666       if(pucchCfg->format3->choice.setup == NULLP)
5667       {
5668          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5669          return RFAILED;
5670       }
5671
5672       if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
5673       {
5674          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5675          return RFAILED;
5676       }
5677    }
5678
5679    /* PUCCH Format 4 */
5680    if(format4Db)
5681    {
5682       DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
5683       if(pucchCfg->format4 == NULLP)
5684       {
5685          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5686          return RFAILED;
5687       }
5688
5689       pucchCfg->format4->present = PUCCH_Config__format4_PR_setup;
5690       DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
5691       if(pucchCfg->format4->choice.setup == NULLP)
5692       {
5693          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5694          return RFAILED;
5695       }
5696
5697       if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
5698       {
5699          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5700          return RFAILED;
5701       }
5702    }
5703
5704    /* Scheduling Request */
5705    if(schReqDb && (schReqDb->schedAddModListCount != 0))
5706    {
5707       pucchCfg->schedulingRequestResourceToAddModList = NULLP;
5708       DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
5709       if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
5710       {
5711          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5712          return RFAILED;
5713       }
5714
5715       if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
5716       {
5717          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5718          return RFAILED;
5719       }
5720    }
5721
5722    /* Multi CSI */
5723    if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
5724    {
5725       pucchCfg->multi_CSI_PUCCH_ResourceList = NULLP;
5726       DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
5727       if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
5728       {
5729          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5730          return RFAILED;
5731       }
5732
5733       if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
5734       {
5735          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5736          return RFAILED;
5737       }
5738    }
5739
5740    /* DL DATA TO UL ACK */
5741    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5742    if(pucchCfg->dl_DataToUL_ACK == NULLP)
5743    {
5744       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5745       return RFAILED;
5746    }
5747
5748    if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
5749    {
5750       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5751       return RFAILED;
5752    }
5753
5754    /* TODO : spatial relation info add/mod list and power control*/
5755
5756    return ROK;
5757 }
5758
5759 /*******************************************************************
5760  *
5761  * @brief Fills SRS resource to add/modify list
5762  *
5763  * @details
5764  *
5765  *    Function : BuildSrsRsrcAddModList
5766  *
5767  *    Functionality: Fills SRS resource to add/modify list
5768  *
5769  * @params[in]
5770  * @return ROK     - success
5771  *         RFAILED - failure
5772  *
5773  * ****************************************************************/
5774 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
5775 {
5776    uint8_t   elementCnt;
5777    uint8_t   rsrcIdx;
5778
5779    elementCnt = 1;
5780    resourceList->list.count = elementCnt;
5781    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
5782    resourceList->list.array = NULLP;
5783    DU_ALLOC(resourceList->list.array, resourceList->list.size);
5784    if(!resourceList->list.array)
5785    {
5786       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5787       return RFAILED;
5788    }
5789
5790    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5791    {
5792       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5793       if(!resourceList->list.array[rsrcIdx])
5794       {
5795          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5796          return RFAILED;
5797       }
5798    }
5799
5800    rsrcIdx = 0;
5801    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
5802    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
5803    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
5804
5805    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
5806    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
5807          sizeof(struct SRS_Resource__transmissionComb__n2));
5808    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
5809    {
5810       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5811       return RFAILED;
5812    }
5813    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
5814       = SRS_COMB_OFFSET_N2;
5815    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
5816       = SRS_CYCLIC_SHIFT_N2;
5817
5818    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
5819                                                                       PUSCH_START_SYMBOL;
5820    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
5821                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
5822    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
5823                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
5824
5825    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
5826    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
5827    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
5828    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
5829    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
5830    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
5831                                                                SRS_Resource__groupOrSequenceHopping_neither;
5832
5833    /* Setting resource type to aperiodic for intergration purposes */
5834    resourceList->list.array[rsrcIdx]->resourceType.present = \
5835                                                              SRS_Resource__resourceType_PR_aperiodic;
5836    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
5837    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
5838          sizeof(struct SRS_Resource__resourceType__aperiodic));
5839    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
5840    {
5841       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5842       return RFAILED;
5843    }
5844
5845    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
5846
5847    return ROK;
5848 }
5849
5850 /*******************************************************************
5851  *
5852  * @brief Build SRS resource set Add/mod list
5853  *
5854  * @details
5855  *
5856  *    Function : BuildSrsRsrcSetAddModList
5857  *
5858  *    Functionality: Build SRS resource set Add/mod list
5859  *
5860  * @params[in]
5861  * @return ROK     - success
5862  *         RFAILED - failure
5863  *
5864  * ****************************************************************/
5865    uint8_t BuildSrsRsrcSetAddModList
5866 (
5867  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
5868  )
5869 {
5870    uint8_t  elementCnt;
5871    uint8_t  rSetIdx;
5872    uint8_t  rsrcIdx;
5873    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
5874
5875    elementCnt = 1;
5876    rsrcSetList->list.count = elementCnt;
5877    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
5878    rsrcSetList->list.array = NULLP;
5879    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
5880    if(!rsrcSetList->list.array)
5881    {
5882       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5883       return RFAILED;
5884    }
5885
5886    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5887    {
5888       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5889       if(!rsrcSetList->list.array[rSetIdx])
5890       {
5891          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5892          return RFAILED;
5893       }
5894    }
5895
5896    rSetIdx = 0;
5897    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
5898
5899    /* Fill Resource Id list in resource set */
5900    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
5901    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5902          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5903    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5904    {
5905       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5906       return RFAILED;
5907    }
5908
5909    elementCnt = 1;
5910    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5911    rsrcIdList->list.count = elementCnt;
5912    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
5913    rsrcIdList->list.array = NULLP;
5914    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
5915    if(!rsrcIdList->list.array)
5916    {
5917       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5918       return RFAILED;
5919    }
5920
5921    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5922    {
5923       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5924       if(!rsrcIdList->list.array[rsrcIdx])
5925       {
5926          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5927          return RFAILED;
5928       }
5929    }
5930
5931    rsrcIdx = 0;
5932    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
5933
5934    /* Fill resource type */
5935    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
5936                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
5937
5938    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
5939    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5940          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5941    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
5942    {
5943       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5944       return RFAILED;
5945    }
5946    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
5947       = APERIODIC_SRS_RESRC_TRIGGER;
5948
5949    /* TODO : Fill values for below IEs as expected by Viavi */
5950    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
5951    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
5952
5953
5954    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
5955    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
5956    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
5957    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
5958    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
5959
5960    return ROK;
5961 }
5962
5963 /*******************************************************************
5964  *
5965  * @brief Builds BWP UL dedicated SRS Config
5966  *
5967  * @details
5968  *
5969  *    Function : BuildBWPUlDedSrsCfg
5970  *
5971  *    Functionality: Builds BWP UL dedicated SRS Config
5972  *
5973  * @params[in] SRS Config
5974  * @return ROK     - success
5975  *         RFAILED - failure
5976  *
5977  * ****************************************************************/
5978 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
5979 {
5980    srsCfg->srs_ResourceSetToReleaseList = NULLP;
5981    srsCfg->srs_ResourceSetToAddModList = NULLP;
5982    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
5983          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5984    if(!srsCfg->srs_ResourceSetToAddModList)
5985    {
5986       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5987       return RFAILED;
5988    }
5989    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
5990    {
5991       return RFAILED;
5992    }
5993
5994    srsCfg->srs_ResourceToReleaseList = NULLP;
5995
5996    /* Resource to Add/Modify list */
5997    srsCfg->srs_ResourceToAddModList = NULLP;
5998    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
5999          sizeof(struct SRS_Config__srs_ResourceToAddModList));
6000    if(!srsCfg->srs_ResourceToAddModList)
6001    {
6002       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
6003       return RFAILED;
6004    }
6005
6006    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
6007    {
6008       return RFAILED;
6009    }
6010    srsCfg->tpc_Accumulation = NULLP;
6011
6012    return ROK;
6013 }
6014
6015
6016
6017 /*******************************************************************
6018  *
6019  * @brief Builds Pusch Serving cell Config
6020  *
6021  * @details
6022  *
6023  *    Function : BuildPuschSrvCellCfg
6024  *
6025  *    Functionality: Builds Pusch Serving cell Config
6026  *
6027  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
6028  *
6029  * @return ROK     - success
6030  *         RFAILED - failure
6031  *
6032  * ****************************************************************/
6033 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
6034 {
6035    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
6036    puschCfg->choice.setup = NULLP;
6037    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
6038    if(!puschCfg->choice.setup)
6039    {
6040       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
6041       return RFAILED;
6042    }
6043
6044    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
6045    puschCfg->choice.setup->rateMatching = NULLP;
6046    puschCfg->choice.setup->xOverhead = NULLP;
6047    puschCfg->choice.setup->ext1 = NULLP;
6048
6049    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
6050    if(!puschCfg->choice.setup->ext1)
6051    {
6052       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
6053       return RFAILED;
6054    }
6055
6056    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
6057    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
6058    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
6059    {
6060       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
6061       return RFAILED;
6062    }
6063    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
6064
6065    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
6066    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
6067    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
6068    {
6069       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
6070       return RFAILED;
6071    }
6072    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
6073
6074    return ROK;
6075 }
6076
6077 /*******************************************************************
6078  *
6079  * @brief Builds inital UL BWP
6080  *
6081  * @details
6082  *
6083  *    Function : BuildInitialUlBWP
6084  *
6085  *    Functionality: Builds initial UL BWP
6086  *
6087  * @params[in] BWP_UplinkDedicated_t *ulBwp
6088  * @return ROK     - success
6089  *         RFAILED - failure
6090  *
6091  * ****************************************************************/
6092 uint8_t BuildInitialUlBWP(InitialUlBwp *initUlBwp, BWP_UplinkDedicated_t *ulBwp)
6093 {
6094    PucchCfg *pucchCfg = NULLP;
6095    PuschCfg *puschCfg = NULLP;
6096
6097    if(initUlBwp)
6098    {
6099       if(initUlBwp->pucchPresent)
6100          pucchCfg = &initUlBwp->pucchCfg;
6101       if(initUlBwp->puschPresent)
6102          puschCfg = &initUlBwp->puschCfg;
6103    }
6104
6105    ulBwp->pucch_Config = NULLP;
6106    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
6107    if(!ulBwp->pucch_Config)
6108    {
6109       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
6110       return RFAILED;
6111    }
6112
6113    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
6114    ulBwp->pucch_Config->choice.setup = NULLP;
6115    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
6116    if(!ulBwp->pucch_Config->choice.setup)
6117    {
6118       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
6119       return RFAILED;
6120    }
6121
6122    if(BuildBWPUlDedPucchCfg(pucchCfg, ulBwp->pucch_Config->choice.setup) != ROK)
6123    {
6124       return RFAILED;
6125    }
6126
6127    /* Fill BWP UL dedicated PUSCH config */
6128    ulBwp->pusch_Config = NULLP;
6129    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
6130    if(!ulBwp->pusch_Config)
6131    {
6132       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
6133       return RFAILED;
6134    }
6135
6136    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
6137    ulBwp->pusch_Config->choice.setup = NULLP;
6138    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
6139    if(!ulBwp->pusch_Config->choice.setup)
6140    {
6141       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
6142       return RFAILED;
6143    }
6144
6145    if(BuildBWPUlDedPuschCfg(puschCfg, ulBwp->pusch_Config->choice.setup) != ROK)
6146    {
6147       return RFAILED;
6148    }
6149
6150    ulBwp->configuredGrantConfig = NULLP;
6151
6152    /* Fill BPW UL dedicated SRS config */
6153    ulBwp->srs_Config = NULLP;
6154    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
6155    if(!ulBwp->srs_Config)
6156    {
6157       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
6158       return RFAILED;
6159    }
6160
6161    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
6162    ulBwp->srs_Config->choice.setup = NULLP;
6163    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
6164    if(!ulBwp->srs_Config->choice.setup)
6165    {
6166       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
6167       return RFAILED;
6168    }
6169
6170    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
6171    {
6172       return RFAILED;
6173    }
6174
6175    ulBwp->beamFailureRecoveryConfig = NULLP;
6176
6177    return ROK;
6178 }
6179
6180 /*******************************************************************
6181  *
6182  * @brief Builds UL config
6183  * @details
6184  *
6185  *    Function : BuildUlCfg
6186  *
6187  *    Functionality: Builds UL config in spCellCfgDed
6188  *
6189  * @params[in] UplinkConfig_t *ulCfg
6190  *
6191  * @return ROK     - success
6192  *         RFAILED - failure
6193  *
6194  * ****************************************************************/
6195 uint8_t BuildUlCfg(ServCellRecfgInfo *servCellRecfg, UplinkConfig_t *ulCfg)
6196 {
6197    InitialUlBwp *initUlBwp = NULLP;
6198
6199    if(servCellRecfg)
6200    {
6201       initUlBwp = &servCellRecfg->initUlBwp;
6202    }
6203
6204    ulCfg->initialUplinkBWP = NULLP;
6205    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
6206    if(!ulCfg->initialUplinkBWP)
6207    {
6208       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
6209       return RFAILED;
6210    }
6211
6212    if(BuildInitialUlBWP(initUlBwp, ulCfg->initialUplinkBWP) != ROK)
6213    {
6214       return RFAILED;
6215    }
6216
6217    ulCfg->uplinkBWP_ToReleaseList = NULLP;
6218    ulCfg->uplinkBWP_ToAddModList = NULLP;
6219    ulCfg->firstActiveUplinkBWP_Id = NULLP;
6220    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
6221    if(!ulCfg->firstActiveUplinkBWP_Id)
6222    {
6223       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
6224       return RFAILED;
6225    }
6226    if(servCellRecfg == NULLP)
6227       *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
6228    else
6229       *(ulCfg->firstActiveUplinkBWP_Id) = servCellRecfg->firstActvUlBwpId;
6230
6231    ulCfg->pusch_ServingCellConfig = NULLP;
6232    DU_ALLOC(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
6233    if(!ulCfg->pusch_ServingCellConfig)
6234    {
6235       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
6236       return RFAILED;
6237    }
6238
6239    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
6240    {
6241       return RFAILED;
6242    }
6243
6244    ulCfg->carrierSwitching = NULLP;
6245    ulCfg->ext1 = NULLP;
6246    return ROK;
6247 }
6248
6249 /*******************************************************************
6250  *
6251  * @brief Builds PDSCH serving cell config
6252  * @details
6253  *
6254  *    Function : BuildPdschSrvCellCfg
6255  *
6256  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
6257  *
6258  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
6259  *
6260  * @return ROK     - success
6261  *         RFAILED - failure
6262  *
6263  * ****************************************************************/
6264 uint8_t BuildPdschSrvCellCfg(PdschServCellCfg *pdschServCellDb, struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
6265 {
6266    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
6267    pdschCfg->choice.setup = NULLP;
6268    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6269    if(!pdschCfg->choice.setup)
6270    {
6271       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6272       return RFAILED;
6273    }
6274
6275    /* Code Block Group Transmission */
6276    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
6277    if(pdschServCellDb && (pdschServCellDb->maxCodeBlkGrpPerTb || pdschServCellDb->codeBlkGrpFlushInd))
6278    {
6279       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission, sizeof(struct PDSCH_ServingCellConfig__codeBlockGroupTransmission));
6280       if(pdschCfg->choice.setup->codeBlockGroupTransmission == NULLP)
6281       {
6282          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6283          return RFAILED;
6284       }
6285
6286       pdschCfg->choice.setup->codeBlockGroupTransmission->present = PDSCH_ServingCellConfig__codeBlockGroupTransmission_PR_setup;
6287       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup = NULLP;
6288       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup, sizeof(struct PDSCH_CodeBlockGroupTransmission ));
6289       if(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup == NULLP)
6290       {
6291          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6292          return RFAILED;
6293       }
6294
6295       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock = \
6296          *(pdschServCellDb->maxCodeBlkGrpPerTb);
6297       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator = \
6298          *(pdschServCellDb->codeBlkGrpFlushInd);
6299    }
6300
6301    /* xOverhead */
6302    pdschCfg->choice.setup->xOverhead = NULLP;
6303    if(pdschServCellDb && pdschServCellDb->xOverhead)
6304    {
6305       DU_ALLOC(pdschCfg->choice.setup->xOverhead, sizeof(long));
6306       if(pdschCfg->choice.setup->xOverhead == NULLP)
6307       {
6308          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6309          return RFAILED;
6310       }
6311       *(pdschCfg->choice.setup->xOverhead) = *(pdschServCellDb->xOverhead);
6312    }
6313
6314    /* Number of HARQ processes */
6315    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
6316    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
6317    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
6318    {
6319       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6320       return RFAILED;
6321    }
6322
6323    if(pdschServCellDb == NULLP)
6324    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = PDSCH_NUM_HARQ_PROC;
6325    else
6326    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = pdschServCellDb->numHarqProcForPdsch;
6327
6328    pdschCfg->choice.setup->pucch_Cell = NULLP;
6329
6330    /* Extension */
6331    pdschCfg->choice.setup->ext1 = NULLP;
6332    if(pdschServCellDb && pdschServCellDb->maxMimoLayers)
6333    {
6334       DU_ALLOC(pdschCfg->choice.setup->ext1, sizeof(struct PDSCH_ServingCellConfig__ext1));
6335       if(pdschCfg->choice.setup->ext1 == NULLP)
6336       {
6337          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6338          return RFAILED;
6339       }
6340
6341       DU_ALLOC(pdschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
6342       if(pdschCfg->choice.setup->ext1->maxMIMO_Layers == NULLP)
6343       {
6344          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6345          return RFAILED;
6346       }
6347       *(pdschCfg->choice.setup->ext1->maxMIMO_Layers) = *(pdschServCellDb->maxMimoLayers);
6348    }
6349
6350    return ROK;
6351 }
6352
6353 /*******************************************************************
6354  *
6355  * @brief Builds CSI Meas config
6356  * @details
6357  *
6358  *    Function : BuildCsiMeasCfg
6359  *
6360  *    Functionality: Builds CSI Meas config in spCellCfgDed
6361  *
6362  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
6363  *
6364  * @return ROK     - success
6365  *         RFAILED - failure
6366  *
6367  * ****************************************************************/
6368 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
6369 {
6370
6371    return ROK;
6372 }
6373
6374 /*******************************************************************
6375  *
6376  * @brief Builds DL BWP to add/modify list
6377  * @details
6378  *
6379  *    Function : BuildDlBwpToAddModList
6380  *
6381  *    Functionality: Builds DL BWP to add/modify list
6382  *
6383  * @params[in] ServCellRecfgInfo *servCellRecfg,
6384  *             struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList
6385  *
6386  * @return ROK     - success
6387  *         RFAILED - failure
6388  *
6389  * ****************************************************************/
6390 uint8_t BuildDlBwpToAddModList(ServCellRecfgInfo *servCellRecfg, struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList)
6391 {
6392    uint8_t elementCnt, idx;
6393
6394    elementCnt = servCellRecfg->numDlBwpToAddOrMod;
6395    dlBwpAddModList->list.count = elementCnt;
6396    dlBwpAddModList->list.size = elementCnt * sizeof(struct BWP_Downlink *);
6397    dlBwpAddModList->list.array = NULLP;
6398    DU_ALLOC(dlBwpAddModList->list.array, dlBwpAddModList->list.size);
6399    if(dlBwpAddModList->list.array == NULLP)
6400    {
6401       DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6402       return RFAILED;
6403    }
6404
6405    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6406    {
6407       DU_ALLOC(dlBwpAddModList->list.array[idx], sizeof(BWP_Downlink_t));
6408       if(dlBwpAddModList->list.array[idx] == NULLP)
6409       {
6410          DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6411          return RFAILED;
6412       }
6413    }
6414
6415    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6416    {
6417       dlBwpAddModList->list.array[idx]->bwp_Id = servCellRecfg->dlBwpToAddOrModList[idx].bwpId;
6418       dlBwpAddModList->list.array[idx]->bwp_Common = NULLP;
6419       dlBwpAddModList->list.array[idx]->bwp_Dedicated = NULLP;
6420    }
6421    return ROK;
6422 }
6423
6424 /*******************************************************************
6425  *
6426  * @brief Builds Spcell config dedicated
6427  * @details
6428  *
6429  *    Function : BuildSpCellCfgDed
6430  *
6431  *    Functionality: Builds sp cell config dedicated in spCellCfg
6432  *
6433  * @params[in] ServingCellConfig_t srvCellCfg
6434  *
6435  * @return ROK     - success
6436  *         RFAILED - failure
6437  *
6438  * ****************************************************************/
6439 uint8_t BuildSpCellCfgDed(DuUeCb *ueCb, ServingCellConfig_t *srvCellCfg)
6440 {
6441    ServCellRecfgInfo *servCellRecfg = NULLP;
6442    InitialDlBwp *initDlBwp = NULLP;
6443    PdschServCellCfg *pdschServCellDb = NULLP;
6444
6445    if(ueCb)
6446    {
6447       servCellRecfg = &ueCb->duMacUeCfg.spCellCfg.servCellCfg;
6448       initDlBwp = &servCellRecfg->initDlBwp;
6449       pdschServCellDb = &servCellRecfg->pdschServCellCfg;
6450    }
6451
6452    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
6453
6454    srvCellCfg->initialDownlinkBWP = NULLP;
6455    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6456    if(!srvCellCfg->initialDownlinkBWP)
6457    {
6458       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6459       return RFAILED;
6460    }
6461
6462    if(BuildInitialDlBWP(initDlBwp, srvCellCfg->initialDownlinkBWP) != ROK)
6463    {
6464       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6465       return RFAILED;
6466    }
6467
6468    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
6469
6470    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
6471    if(ueCb && ueCb->duMacUeCfg.spCellCfg.servCellCfg.numDlBwpToAddOrMod)
6472    {
6473       DU_ALLOC(srvCellCfg->downlinkBWP_ToAddModList, sizeof(struct ServingCellConfig__downlinkBWP_ToAddModList));
6474       if(srvCellCfg->downlinkBWP_ToAddModList == NULLP)
6475       {
6476          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6477          return RFAILED;
6478       }
6479
6480       if(BuildDlBwpToAddModList(&ueCb->duMacUeCfg.spCellCfg.servCellCfg, srvCellCfg->downlinkBWP_ToAddModList) != ROK)
6481       {
6482          DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6483          return RFAILED;
6484       }
6485    }
6486
6487    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
6488    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6489    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
6490    {
6491       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6492       return RFAILED;
6493    }
6494    if(ueCb == NULLP)
6495       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6496    else
6497       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ueCb->duMacUeCfg.spCellCfg.servCellCfg.firstActvDlBwpId;
6498
6499    srvCellCfg->bwp_InactivityTimer = NULLP;
6500
6501    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
6502    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6503    if(!srvCellCfg->defaultDownlinkBWP_Id)
6504    {
6505       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6506       return RFAILED;
6507    }
6508    if(ueCb == NULLP)
6509       *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6510    else
6511       *(srvCellCfg->defaultDownlinkBWP_Id) = ueCb->duMacUeCfg.spCellCfg.servCellCfg.defaultDlBwpId;
6512
6513    srvCellCfg->uplinkConfig = NULLP;
6514    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6515    if(!srvCellCfg->uplinkConfig)
6516    {
6517       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6518       return RFAILED;
6519    }
6520
6521    if(BuildUlCfg(servCellRecfg, srvCellCfg->uplinkConfig) != ROK)
6522    {
6523       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
6524       return RFAILED;
6525    }
6526    srvCellCfg->supplementaryUplink = NULLP;
6527    srvCellCfg->pdcch_ServingCellConfig = NULLP;
6528
6529    srvCellCfg->pdsch_ServingCellConfig = NULLP;
6530    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
6531    if(!srvCellCfg->pdsch_ServingCellConfig)
6532    {
6533       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6534       return RFAILED;
6535    }
6536
6537    if(BuildPdschSrvCellCfg(pdschServCellDb, srvCellCfg->pdsch_ServingCellConfig) != ROK)
6538    {
6539       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
6540       return RFAILED;
6541    }
6542
6543    srvCellCfg->csi_MeasConfig = NULLP;
6544 #if 0
6545    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
6546       if(!srvCellCfg->csi_MeasConfig)
6547       {
6548          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6549          return RFAILED;
6550       }
6551
6552    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
6553    {
6554       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
6555       return RFAILED;
6556    }
6557 #endif
6558    srvCellCfg->sCellDeactivationTimer = NULLP;
6559    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
6560    srvCellCfg->tag_Id = TAG_ID;
6561    srvCellCfg->dummy = NULLP;
6562    srvCellCfg->pathlossReferenceLinking = NULLP;
6563    srvCellCfg->servingCellMO = NULLP;
6564    srvCellCfg->ext1 = NULLP;
6565
6566    return ROK;
6567 }
6568
6569 /*******************************************************************
6570  *
6571  * @brief Fills SCS specific carrier list in DL frequency info
6572  *
6573  * @details
6574  *
6575  *    Function : BuildScsSpecificCarrierListDl
6576  *
6577  *    Functionality: Fills SCS specific carrier list in DL frequency info
6578  *
6579  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
6580  *
6581  * @return ROK     - success
6582  *         RFAILED - failure
6583  *
6584  * ****************************************************************/
6585 uint8_t BuildScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
6586 {
6587    uint8_t elementCnt = 0, listIdx = 0;
6588    ScsSpecCarrier duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.dlScsCarrier;
6589
6590    elementCnt = ODU_VALUE_ONE;
6591    scsCarrierList->list.count = elementCnt;
6592    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6593
6594    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6595    if(!scsCarrierList->list.array)
6596    {
6597       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for scs carrier list array \
6598          in BuildScsSpecificCarrierListDl()");
6599       return RFAILED;
6600    }
6601
6602    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6603    {
6604       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6605       if(!scsCarrierList->list.array[listIdx])
6606       {
6607          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SCS Specific Carrier list array \
6608             element in BuildScsSpecificCarrierListDl()");
6609          return RFAILED;
6610       }
6611    }
6612
6613    listIdx = 0;
6614    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6615    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6616    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6617
6618    return ROK;
6619 }
6620
6621 /*******************************************************************
6622  *
6623  * @brief Fills DL frequency info in DL config common
6624  *
6625  * @details
6626  *
6627  *    Function : BuildFreqInfoDl
6628  *
6629  *    Functionality: Fills DL frequency info in DL config common
6630  *
6631  * @params[in] Pointer to DownlinkConfigCommon_t
6632  *
6633  * @return ROK     - success
6634  *         RFAILED - failure
6635  *
6636  * ****************************************************************/
6637 uint8_t BuildFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
6638 {
6639    uint8_t freqBandIdx = 0, elementCnt = 0;
6640    DlCfgCommon  dlCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg;
6641
6642    /* TODO : Fill SSB Absolute Frequency */
6643    /*
6644       DU_ALLOC(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
6645       if(!frequencyInfoDL->absoluteFrequencySSB)
6646       {
6647       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB Absolute Frequency in BuildFreqInfoDl()");
6648       return RFAILED;
6649       }
6650       frequencyInfoDL->absoluteFrequencySSB = ?;
6651       */
6652
6653    /* NR Multi Frequency Band List */
6654    elementCnt = ODU_VALUE_ONE;
6655    frequencyInfoDL->frequencyBandList.list.count = elementCnt;
6656    frequencyInfoDL->frequencyBandList.list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6657
6658    DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
6659    if(!frequencyInfoDL->frequencyBandList.list.array)
6660    {
6661       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for Frequency Band List array in BuildFreqInfoDl()");
6662       return RFAILED;
6663    }
6664
6665    for(freqBandIdx = 0; freqBandIdx < elementCnt; freqBandIdx++)
6666    {
6667       DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
6668       if(!frequencyInfoDL->frequencyBandList.list.array[freqBandIdx])
6669       {
6670          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoDl()");
6671          return RFAILED;
6672       }
6673    }
6674
6675    freqBandIdx = 0;
6676    *(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx]) = dlCfg.freqBandInd;
6677
6678    /* TODO : Absolute Frequency to Point A */
6679    //frequencyInfoDL->absoluteFrequencyPointA
6680
6681    /* Subcarrier Spacing specifc carrier List */
6682    if((BuildScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList)) != ROK)
6683    {
6684       DU_LOG("\nERROR  -->  DU APP : Failed to fill SCS specific carrier list DL in BuildFreqInfoDl()");
6685       return RFAILED;
6686    }
6687
6688    return ROK;
6689
6690 }
6691
6692 /*******************************************************************
6693  *
6694  * @brief Fills DL config common in Serving cell config common
6695  *
6696  * @details
6697  *
6698  *    Function : BuildDlConfigCommon
6699  *
6700  *    Functionality: Fills DL config common in Serving cell config common
6701  *
6702  * @params[in] Pointer to DownlinkConfigCommon_t
6703  *
6704  * @return ROK     - success
6705  *         RFAILED - failure
6706  *
6707  * ****************************************************************/
6708 uint8_t BuildDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
6709 {
6710    /* DL Frequency Info */
6711    DU_ALLOC(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
6712    if(!dlCfgCommon->frequencyInfoDL)
6713    {
6714       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL frequency info in BuildDlConfigCommon()");
6715       return RFAILED;
6716    }
6717    if((BuildFreqInfoDl(dlCfgCommon->frequencyInfoDL))!= ROK)
6718    {
6719       DU_LOG("\nERROR  --> DU APP : Failed to fill DL frequency info in BuildDlConfigCommon()");
6720       return RFAILED;
6721    }
6722
6723    /* DL BWP config common */
6724    DU_ALLOC(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
6725    if(!dlCfgCommon->initialDownlinkBWP)
6726    {
6727       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL BWP config common in BuildDlConfigCommon()");
6728       return RFAILED;
6729    }
6730    if((BuildBwpDlCommon(dlCfgCommon->initialDownlinkBWP)) != ROK)
6731    {
6732       DU_LOG("\nERROR  --> DU APP : Failed to fill DL DWP config common in BuildDlConfigCommon()");
6733       return RFAILED;
6734    }
6735
6736    return ROK;
6737 }
6738
6739 /*******************************************************************
6740  *
6741  * @brief Fills SCS specific carrier list in UL frequency Info
6742  *
6743  * @details
6744  *
6745  *    Function : BuildScsSpecificCarrierListUl
6746  *
6747  *    Functionality: Fills SCS specific carrier list in UL frequency Info
6748  *
6749  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
6750  *
6751  * @return ROK     - success
6752  *         RFAILED - failure
6753  *
6754  * ****************************************************************/
6755 uint8_t BuildScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
6756 {
6757    uint8_t elementCnt = 0, listIdx = 0;
6758    ScsSpecCarrier   duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.ulScsCarrier;
6759
6760    elementCnt = ODU_VALUE_ONE;
6761    scsCarrierList->list.count = elementCnt;
6762    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6763
6764    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6765    if(!scsCarrierList->list.array)
6766    {
6767       DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6768       return RFAILED;
6769    }
6770
6771    for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
6772    {
6773       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6774       if(!scsCarrierList->list.array[listIdx])
6775       {
6776          DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6777          return RFAILED;
6778       }
6779    }
6780    listIdx = 0;
6781    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6782    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6783    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6784
6785    return ROK;
6786 }
6787
6788 /*******************************************************************
6789  *
6790  * @brief Fills frequency info in UL config common
6791  *
6792  * @details
6793  *
6794  *    Function : BuildFreqInfoUl
6795  *
6796  *    Functionality: Fills frequency info in UL config common
6797  *
6798  * @params[in] Pointer to FrequencyInfoUL_t
6799  *
6800  * @return ROK     - success
6801  *         RFAILED - failure
6802  *
6803  * ****************************************************************/
6804 uint8_t BuildFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
6805 {
6806    uint8_t elementCnt = 0, listIdx= 0;
6807    UlCfgCommon  ulCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg;
6808
6809    /* NR Multi Frequency Band List */
6810    DU_ALLOC(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
6811    if(!frequencyInfoUL->frequencyBandList)
6812    {
6813       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band list in BuildFreqInfoUl()");
6814       return RFAILED;
6815    }
6816
6817    elementCnt = ODU_VALUE_ONE;
6818    frequencyInfoUL->frequencyBandList->list.count = elementCnt;
6819    frequencyInfoUL->frequencyBandList->list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6820
6821    DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
6822    if(!frequencyInfoUL->frequencyBandList->list.array)
6823    {
6824       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array in BuildFreqInfoUl()");
6825       return RFAILED;
6826    }
6827
6828    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6829    {
6830       DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
6831       if(!frequencyInfoUL->frequencyBandList->list.array[listIdx])
6832       {
6833          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoUl()");
6834          return RFAILED;
6835       }
6836    }
6837
6838    listIdx = 0;
6839    *(frequencyInfoUL->frequencyBandList->list.array[listIdx]) = ulCfg.freqBandInd;
6840
6841    /* TODO : Fill Absolute frequency point A */
6842    /*
6843       DU_ALLOC(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
6844       if(!frequencyInfoUL->absoluteFrequencyPointA)
6845       {
6846       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for absolute frequency point A in BuildFreqInfoUl()");
6847       return RFAILED;
6848       }
6849     *(frequencyInfoUL->absoluteFrequencyPointA) = ?;
6850     */
6851
6852    /* Subcarrier Spacing specifc carrier */
6853    if((BuildScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList)) != ROK)
6854    {
6855       DU_LOG("\nERROR  --> DU APP : Failed to fill SCS Specific Carrier list UL in BuildFreqInfoUl()");
6856       return RFAILED;
6857    }
6858
6859    /* P-MAX */
6860    DU_ALLOC(frequencyInfoUL->p_Max, sizeof(P_Max_t));
6861    if(!frequencyInfoUL->p_Max)
6862    {
6863       DU_LOG("\nERROR  -->  DU APP : UL Frequency Infoo  memory allocation failure");
6864       return RFAILED;
6865    }
6866    *frequencyInfoUL->p_Max = ulCfg.pMax;
6867
6868    return ROK;
6869 }
6870
6871 /*******************************************************************
6872  *
6873  * @brief Fills UL config common in Serving cell config common
6874  *
6875  * @details
6876  *
6877  *    Function : BuildUlConfigCommon
6878  *
6879  *    Functionality: Fills UL config common in Serving cell config common
6880  *
6881  * @params[in] Pointer to UplinkConfigCommon_t
6882  *
6883  * @return ROK     - success
6884  *         RFAILED - failure
6885  *
6886  * ****************************************************************/
6887 uint8_t BuildUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
6888 {
6889    /* UL Frequency Info */
6890    DU_ALLOC(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
6891    if(!ulCfgCommon->frequencyInfoUL)
6892    {
6893       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for UL frequency info in BuildUlConfigCommon()");
6894       return RFAILED;
6895    }
6896
6897    if((BuildFreqInfoUl(ulCfgCommon->frequencyInfoUL)) != ROK)
6898    {
6899       DU_LOG("\nERROR  -->  DU APP : Failed to fill frequency info UL in BuildUlConfigCommon()");
6900       return RFAILED;
6901    }
6902
6903    /* UL BWP common */
6904    DU_ALLOC(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
6905    if(!ulCfgCommon->initialUplinkBWP)
6906    {
6907       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for initial UL BWP in BuildUlConfigCommon()");
6908       return RFAILED;
6909    }
6910
6911    if((BuildBwpUlCommon(ulCfgCommon->initialUplinkBWP)) != ROK)
6912    {
6913       DU_LOG("\nERROR  -->  DU APP : Failed to fill BWP UL common in BuildUlConfigCommon()");
6914       return RFAILED;
6915    }
6916
6917    /* Time Alignment timer */
6918    ulCfgCommon->dummy = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.timeAlignTimerComm;
6919
6920    return ROK;
6921 }
6922
6923 /*******************************************************************
6924  *
6925  * @brief Fills SSB position in burst in SP cell config common
6926  *
6927  * @details
6928  *
6929  *    Function : BuildSsbPosInBurst
6930  *
6931  *    Functionality:
6932  *       Fills SSB position in burst in SP cell config common
6933  *
6934  * @params[in] Pointer to struct ServingCellConfigCommon__ssb_PositionsInBurst
6935  *
6936  * @return ROK     - success
6937  *         RFAILED - failure
6938  *
6939  * ****************************************************************/
6940 uint8_t BuildSsbPosInBurst(struct ServingCellConfigCommon__ssb_PositionsInBurst *ssbPosInBurst)
6941 {
6942    uint8_t bitStringSizeInBytes = 0;
6943
6944    ssbPosInBurst->present = ServingCellConfigCommon__ssb_PositionsInBurst_PR_mediumBitmap;
6945
6946    /* As per spec 38.331,in the definition of ServingCellConfigCommon */
6947    bitStringSizeInBytes = 1;
6948    ssbPosInBurst->choice.mediumBitmap.size = bitStringSizeInBytes * sizeof(uint8_t);
6949
6950    DU_ALLOC(ssbPosInBurst->choice.mediumBitmap.buf, ssbPosInBurst->choice.mediumBitmap.size);
6951    if(!ssbPosInBurst->choice.mediumBitmap.buf)
6952    {
6953       DU_LOG("\nERROR  -->  DU APP : Memory Allocation failed for medium bit map buffer in BuildSsbPosInBurst()");
6954       return RFAILED;
6955    }
6956
6957    if((fillBitString(&ssbPosInBurst->choice.mediumBitmap, 0, bitStringSizeInBytes, \
6958                duCfgParam.sib1Params.srvCellCfgCommSib.ssbPosInBurst)) != ROK)
6959    {
6960       DU_LOG("\nERROR  -->  DU APP : Failed to fill medium bit map in BuildSsbPosInBurst()");
6961       return RFAILED;
6962    }
6963
6964    return ROK;
6965 }
6966
6967 /*******************************************************************
6968  *
6969  * @brief Fills SP cell config common in Reconfig with Sync
6970  *
6971  * @details
6972  *
6973  *    Function : BuildSpCellConfigCommon
6974  *
6975  *    Functionality: Fills SP cell config common in Reconfig with Sync
6976  *
6977  * @params[in] Pointer to ServingCellConfigCommon_t
6978  *
6979  * @return ROK     - success
6980  *         RFAILED - failure
6981  *
6982  * ****************************************************************/
6983 uint8_t BuildSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
6984 {
6985    /* Physical Cell Identity */
6986    DU_ALLOC(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
6987    if(!spCellConfigCommon->physCellId)
6988    {
6989       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for physical cell id in BuildSpCellConfigCommon()");
6990       return RFAILED;
6991    }
6992    *(spCellConfigCommon->physCellId) = NR_PCI;
6993
6994    /* Downlink Config Common */
6995    DU_ALLOC(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
6996    if(!spCellConfigCommon->downlinkConfigCommon)
6997    {
6998       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for DL Config Common in BuildSpCellConfigCommon()");
6999       return RFAILED;
7000    }
7001    if((BuildDlConfigCommon(spCellConfigCommon->downlinkConfigCommon)) != ROK)
7002    {
7003       DU_LOG("\nERROR  -->  DU APP : Failed to fill DL config commin in BuildSpCellConfigCommon()");
7004       return RFAILED;
7005    }
7006
7007    /* Uplinlink Config Common */
7008    DU_ALLOC(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
7009    if(!spCellConfigCommon->uplinkConfigCommon)
7010    {
7011       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for UL Config Common in BuildSpCellConfigCommon()");
7012       return RFAILED;
7013    }
7014    if((BuildUlConfigCommon(spCellConfigCommon->uplinkConfigCommon)) != ROK)
7015    {
7016       DU_LOG("\nERROR  -->  DU APP : Failed to fill UL config commin in BuildSpCellConfigCommon()");
7017       return RFAILED;
7018    }
7019
7020    /* Timing Advance offset */
7021    DU_ALLOC(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
7022    if(!spCellConfigCommon->n_TimingAdvanceOffset)
7023    {
7024       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for Timing Advance Offset in BuildSpCellConfigCommon()");
7025       return RFAILED;
7026    }
7027    *(spCellConfigCommon->n_TimingAdvanceOffset) = ServingCellConfigCommon__n_TimingAdvanceOffset_n0;
7028
7029    /* SSB Position In Burst */
7030    DU_ALLOC(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
7031    if(!spCellConfigCommon->ssb_PositionsInBurst)
7032    {
7033       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Position In Burst in BuildSpCellConfigCommon()");
7034       return RFAILED;
7035    }
7036    if((BuildSsbPosInBurst(spCellConfigCommon->ssb_PositionsInBurst)) != ROK)
7037    {
7038       DU_LOG("\nERROR  -->  DU APP : Failed to fill SSB Position In Burst in BuildSpCellConfigCommon()");
7039       return RFAILED;
7040    }
7041
7042    /* SSB Periodicity in Serving cell */
7043    DU_ALLOC(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
7044    if(!spCellConfigCommon->ssb_periodicityServingCell)
7045    {
7046       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Periodicity serving cell in \
7047          BuildSpCellConfigCommon()");
7048       return RFAILED;
7049    }
7050    *(spCellConfigCommon->ssb_periodicityServingCell) = \
7051       convertSsbPeriodicityValueToEnum(duCfgParam.sib1Params.srvCellCfgCommSib.ssbPrdServingCell);
7052
7053    /* DMRS Type A position */
7054    spCellConfigCommon->dmrs_TypeA_Position = convertDmrsTypeAPosValueToEnum(duCfgParam.macCellCfg.ssbCfg.dmrsTypeAPos);
7055
7056    /* SSB subcarrier spacing */
7057    DU_ALLOC(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7058    if(!spCellConfigCommon->ssbSubcarrierSpacing)
7059    {
7060       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for sub-carrier spacing in BuildSpCellConfigCommon()");
7061       return RFAILED;
7062    }
7063    *(spCellConfigCommon->ssbSubcarrierSpacing) = duCfgParam.sib1Params.srvCellCfgCommSib.scs;
7064
7065    /* TDD UL-DL configuration common */
7066    DU_ALLOC(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
7067    if(!spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)
7068    {
7069       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for TDD UL-DL config common in BuildSpCellConfigCommon()");
7070       return RFAILED;
7071    }
7072    if((BuildTddUlDlCfgComm(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)) != ROK)
7073    {
7074       DU_LOG("\nERROR  -->  DU APP : Failed to fill TDD UL-DL config common in BuildSpCellConfigCommon()");
7075       return RFAILED;
7076    }
7077
7078    /* SS PBCH Block Power */
7079    spCellConfigCommon->ss_PBCH_BlockPower = duCfgParam.sib1Params.srvCellCfgCommSib.ssPbchBlockPwr;
7080
7081    return ROK;
7082 }
7083
7084 /*******************************************************************
7085  *
7086  * @brief Fills dedicated RACH configuration in Reconfiguration with sync
7087  *
7088  * @details
7089  *
7090  *    Function : BuildRecfgWithSync
7091  *
7092  *    Functionality:
7093  *       Fills dedicated RACH configuration in Reconfiguration with sync
7094  *
7095  * @params[in] DU UE CB
7096  *             Pointer to Rach config dedicated struct
7097  *
7098  * @return ROK     - success
7099  *         RFAILED - failure
7100  *
7101  * ****************************************************************/
7102 uint8_t BuildRachConfigDedicated(DuUeCb *ueCb, struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
7103 {
7104    uint8_t elementCnt = 0, listIdx = 0;
7105    CFRA_t *cfra = NULLP;
7106    struct CFRA__resources__ssb *ssbResource = NULLP;
7107    RachCfgCommon duRachCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.rachCfg;
7108
7109    rachCfgDed->present = ReconfigurationWithSync__rach_ConfigDedicated_PR_uplink;
7110
7111    /* Uplink */
7112    DU_ALLOC(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
7113    if(!rachCfgDed->choice.uplink)
7114    {
7115       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for RACH uplink configuration in BuildRachConfigDedicated()");
7116       return RFAILED;
7117    }
7118
7119    /* CFRA : Contention free Random Access */
7120    DU_ALLOC(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
7121    if(!rachCfgDed->choice.uplink->cfra)
7122    {
7123       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA in BuildRachConfigDedicated()");
7124       return RFAILED;
7125    }
7126    cfra = rachCfgDed->choice.uplink->cfra;
7127
7128    /* CFRA occassions */
7129    DU_ALLOC(cfra->occasions, sizeof(struct CFRA__occasions));
7130    if(!cfra->occasions)
7131    {
7132       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA occassion in BuildRachConfigDedicated()");
7133       return RFAILED;
7134    }
7135
7136    /* CFRA occassions : RACH generic configuration */
7137    cfra->occasions->rach_ConfigGeneric.prach_ConfigurationIndex = duRachCfg.prachCfgIdx;
7138    cfra->occasions->rach_ConfigGeneric.msg1_FDM = duRachCfg.msg1Fdm;
7139    cfra->occasions->rach_ConfigGeneric.msg1_FrequencyStart = duRachCfg.msg1FreqStart;
7140    cfra->occasions->rach_ConfigGeneric.zeroCorrelationZoneConfig = duRachCfg.zeroCorrZoneCfg;
7141    cfra->occasions->rach_ConfigGeneric.preambleReceivedTargetPower = duRachCfg.preambleRcvdTgtPwr;
7142    cfra->occasions->rach_ConfigGeneric.preambleTransMax = duRachCfg.preambleTransMax;
7143    cfra->occasions->rach_ConfigGeneric.powerRampingStep = duRachCfg.pwrRampingStep;
7144    cfra->occasions->rach_ConfigGeneric.ra_ResponseWindow = duRachCfg.raRspWindow;
7145
7146    /* CFRA occassions : SSB per RACH occasion */
7147    DU_ALLOC(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
7148    if(!cfra->occasions->ssb_perRACH_Occasion)
7149    {
7150       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB per RACH occassion in BuildRachConfigDedicated()");
7151       return RFAILED;
7152    }
7153    *(cfra->occasions->ssb_perRACH_Occasion) = convertCFRASsbPerRachOccasionValueToEnum(duCfgParam.macCellCfg.prachCfg.ssbPerRach);
7154
7155    /* CFRA resource */
7156    cfra->resources.present = CFRA__resources_PR_ssb;
7157
7158    /* CFRA resource : SSB */
7159    DU_ALLOC(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
7160    if(!cfra->resources.choice.ssb)
7161    {
7162       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA resource - SSB in BuildRachConfigDedicated()");
7163       return RFAILED;
7164    }
7165    ssbResource = cfra->resources.choice.ssb;
7166
7167    /* CFRA SSB resource list */
7168    elementCnt = ueCb->cfraResource.numSsb;
7169    ssbResource->ssb_ResourceList.list.count = elementCnt;
7170    ssbResource->ssb_ResourceList.list.size = elementCnt * sizeof(CFRA_SSB_Resource_t *);
7171
7172    DU_ALLOC(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
7173    if(!ssbResource->ssb_ResourceList.list.array)
7174    {
7175       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list in BuildRachConfigDedicated()");
7176       return RFAILED;
7177    }
7178
7179    for(listIdx = 0; listIdx < elementCnt; listIdx++)
7180    {
7181       DU_ALLOC(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
7182       if(!ssbResource->ssb_ResourceList.list.array[listIdx])
7183       {
7184          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list element in BuildRachConfigDedicated()");
7185          return RFAILED;
7186       }
7187       ssbResource->ssb_ResourceList.list.array[listIdx]->ssb = ueCb->cfraResource.ssbResource[listIdx].ssbIdx;
7188       ssbResource->ssb_ResourceList.list.array[listIdx]->ra_PreambleIndex = ueCb->cfraResource.ssbResource[listIdx].raPreambleIdx;
7189    }
7190
7191    return ROK;
7192 }
7193
7194 /*******************************************************************
7195  *
7196  * @brief Fills reconfiguration with sync in SP cell config
7197  *
7198  * @details
7199  *
7200  *    Function : BuildRecfgWithSync
7201  *
7202  *    Functionality: Fills reconfiguration with sync in SP cell config
7203  *
7204  * @params[in] DU UE CB
7205  *             Pointer to ReconfigurationWithSync_t
7206  *
7207  * @return ROK     - success
7208  *         RFAILED - failure
7209  *
7210  * ****************************************************************/
7211 uint8_t BuildRecfgWithSync(DuUeCb *ueCb, ReconfigurationWithSync_t *recfgWithSync)
7212 {
7213    /* SP Cell Config Common */
7214    DU_ALLOC(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
7215    if(!recfgWithSync->spCellConfigCommon)
7216    {
7217       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for spCellConfigCommon in BuildRecfgWithSync()");
7218       return RFAILED;
7219    }
7220
7221    if((BuildSpCellConfigCommon(recfgWithSync->spCellConfigCommon)) != ROK)
7222    {
7223       DU_LOG("\nERROR  -->  DU APP : Failed to build SpCellConfigCommon in BuildRecfgWithSync()");
7224       return RFAILED;
7225    }
7226
7227    /* New UE Identity */
7228    recfgWithSync->newUE_Identity = ueCb->crnti;
7229
7230    /* T304 timer */
7231    recfgWithSync->t304 = ReconfigurationWithSync__t304_ms1000;
7232
7233    /* RACH configuration dedicated */
7234    DU_ALLOC(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
7235    if(!recfgWithSync->rach_ConfigDedicated)
7236    {
7237       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for RACH config dedicated in BuildRecfgWithSync()");
7238       return RFAILED;
7239    }
7240
7241    if((BuildRachConfigDedicated(ueCb, recfgWithSync->rach_ConfigDedicated)) != ROK)
7242    {
7243       DU_LOG("\nERROR  -->  DU APP : Failed to build RACH config dedicated in BuildRecfgWithSync()");
7244       return RFAILED;
7245    }
7246
7247    return ROK;
7248 }
7249
7250 /*******************************************************************
7251  *
7252  * @brief Builds Spcell config
7253  *
7254  * @details
7255  *
7256  *    Function : BuildSpCellCfg
7257  *
7258  *    Functionality: Builds sp cell config in DuToCuRrcContainer
7259  *
7260  * @params[in] SpCellConfig_t spCellCfg
7261  *
7262  * @return ROK     - success
7263  *         RFAILED - failure
7264  *
7265  * ****************************************************************/
7266 uint8_t BuildSpCellCfg(DuUeCb *ueCb, SpCellConfig_t *spCellCfg)
7267 {
7268    spCellCfg->servCellIndex = NULLP;
7269    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
7270    if(!spCellCfg->servCellIndex)
7271    {
7272       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
7273       return RFAILED;
7274    }
7275
7276    if(ueCb == NULLP)
7277       *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
7278    else
7279       *(spCellCfg->servCellIndex) = ueCb->duMacUeCfg.spCellCfg.servCellIdx;
7280
7281    spCellCfg->reconfigurationWithSync = NULLP;
7282    if(ueCb && (ueCb->ueState == UE_HANDIN_IN_PROGRESS))
7283    {
7284       DU_ALLOC(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
7285       if(!spCellCfg->reconfigurationWithSync)
7286       {
7287          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
7288          return RFAILED;
7289       }
7290
7291       if((BuildRecfgWithSync(ueCb, spCellCfg->reconfigurationWithSync)) != ROK)
7292       {
7293          DU_LOG("\nERROR  -->  F1AP : Building of reconfiguration with sync failed at BuildSpCellCfg");
7294          return RFAILED;
7295       }
7296    }
7297
7298    spCellCfg->rlf_TimersAndConstants = NULLP;
7299    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
7300
7301    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
7302    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
7303    {
7304       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
7305       return RFAILED;
7306    }
7307    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
7308
7309    spCellCfg->spCellConfigDedicated = NULLP;
7310    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
7311    if(!spCellCfg->spCellConfigDedicated)
7312    {
7313       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
7314       return RFAILED;
7315    }
7316    if(BuildSpCellCfgDed(ueCb, spCellCfg->spCellConfigDedicated) != ROK)
7317    {
7318       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
7319       return RFAILED;
7320    }
7321
7322    return ROK;
7323 }
7324
7325 /*******************************************************************
7326  *
7327  * @brief Builds Phy cell group config
7328  *
7329  * @details
7330  *
7331  *    Function : BuildPhyCellGrpCfg
7332  *
7333  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
7334  *
7335  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
7336  *
7337  * @return ROK     - success
7338  *         RFAILED - failure
7339  *
7340  * ****************************************************************/
7341 uint8_t BuildPhyCellGrpCfg(DuUeCb *ueCb, PhysicalCellGroupConfig_t *phyCellGrpCfg)
7342 {
7343    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
7344    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
7345
7346    phyCellGrpCfg->p_NR_FR1 = NULLP;
7347    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
7348    if(!phyCellGrpCfg->p_NR_FR1)
7349    {
7350       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
7351       return RFAILED;
7352    }
7353
7354    if(ueCb == NULLP)
7355    {
7356       *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
7357       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
7358    }
7359    else
7360    {
7361       *(phyCellGrpCfg->p_NR_FR1) = ueCb->duMacUeCfg.phyCellGrpCfg.pNrFr1;
7362       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = ueCb->duMacUeCfg.phyCellGrpCfg.pdschHarqAckCodebook;
7363    }
7364
7365    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
7366    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
7367    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
7368    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
7369    phyCellGrpCfg->cs_RNTI = NULLP;
7370    phyCellGrpCfg->ext1 = NULLP;
7371    phyCellGrpCfg->ext2 = NULLP;
7372
7373    return ROK;
7374 }
7375 #ifdef NR_DRX
7376 /*******************************************************************
7377  *
7378  * @brief fill long cycle offset value of drx
7379  *
7380  * @details
7381  *
7382  *    Function : fillLongCycleOffsetValFromDuCb
7383  *
7384  *    Functionality: fill long cycle offset value of drx
7385  *
7386  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
7387  * struct DRX_ConfigRrc__drx_LongCycleStartOffset drx_LongCycleStartOffset
7388  *
7389  * @return ROK     - success
7390  *         RFAILED - failure
7391  *
7392  * ****************************************************************/
7393 void fillLongCycleOffsetValFromDuCb(DrxLongCycleStartOffset  drxLongCycleStartOffset,\
7394 struct DRX_ConfigRrc__drx_LongCycleStartOffset *drx_LongCycleStartOffset)
7395 {
7396
7397    drx_LongCycleStartOffset->present = convertLongDrxCycleLengthValueToEnum(drxLongCycleStartOffset.drxLongCycleStartOffsetChoice);
7398    switch(drx_LongCycleStartOffset->present)
7399    {
7400       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
7401          {
7402             drx_LongCycleStartOffset->choice.ms10 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7403             break;
7404          }
7405       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
7406          {
7407             drx_LongCycleStartOffset->choice.ms20 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7408             break;
7409          }
7410       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
7411          {
7412             drx_LongCycleStartOffset->choice.ms32 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7413             break;
7414          }
7415       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
7416          {
7417             drx_LongCycleStartOffset->choice.ms40 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7418             break;
7419          }
7420       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
7421          {
7422             drx_LongCycleStartOffset->choice.ms60 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7423             break;
7424          }
7425       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
7426          {
7427             drx_LongCycleStartOffset->choice.ms64 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7428             break;
7429          }
7430       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
7431          {
7432             drx_LongCycleStartOffset->choice.ms70 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7433             break;
7434          }
7435       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
7436          {
7437             drx_LongCycleStartOffset->choice.ms80 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7438             break;
7439          }
7440       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
7441          {
7442             drx_LongCycleStartOffset->choice.ms128 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7443             break;
7444          }
7445       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
7446          {
7447             drx_LongCycleStartOffset->choice.ms160 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7448             break;
7449          }
7450       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
7451          {
7452             drx_LongCycleStartOffset->choice.ms256 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7453             break;
7454          }
7455       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
7456          {
7457             drx_LongCycleStartOffset->choice.ms320 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7458             break;
7459          }
7460       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
7461          {
7462             drx_LongCycleStartOffset->choice.ms512 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7463             break;
7464          }
7465       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
7466          {
7467             drx_LongCycleStartOffset->choice.ms640 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7468             break;
7469          }
7470       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
7471          {
7472             drx_LongCycleStartOffset->choice.ms1024 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7473             break;
7474          }
7475       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
7476          {
7477             drx_LongCycleStartOffset->choice.ms1280 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7478             break;
7479          }
7480       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
7481          {
7482             drx_LongCycleStartOffset->choice.ms2048 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7483             break;
7484          }
7485       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
7486          {
7487             drx_LongCycleStartOffset->choice.ms2560 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7488             break;
7489          }
7490       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
7491          {
7492             drx_LongCycleStartOffset->choice.ms5120 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7493             break;
7494          }
7495       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
7496          {
7497             drx_LongCycleStartOffset->choice.ms10240 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7498             break;
7499          }
7500       default :
7501          break;
7502    }
7503 }
7504 /*******************************************************************
7505  *
7506  * @brief Builds drx config IE
7507  *
7508  * @details
7509  *
7510  *    Function : BuildDrxConfigRrc
7511  *
7512  *    Functionality: Build drx config in MacCellGrpCfg
7513  *
7514  * @params[in] struct MAC_CellGroupConfig__drx_ConfigRrc
7515  *
7516  * @return ROK     - success
7517  *         RFAILED - failure
7518  *
7519  * ****************************************************************/
7520 uint8_t BuildDrxConfigRrc(DuUeCb *ueCb, struct MAC_CellGroupConfig__drx_ConfigRrc *drxCfg)
7521 {
7522    drxCfg->present = MAC_CellGroupConfig__drx_ConfigRrc_PR_setup;
7523    DU_ALLOC(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
7524    if(!drxCfg->choice.setup)
7525    {
7526       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDrxConfigRrc");
7527       return RFAILED;
7528    }
7529    if(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationTimerValInMs)
7530    {
7531       drxCfg->choice.setup->drx_onDurationTimer.present = DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds;
7532       drxCfg->choice.setup->drx_onDurationTimer.choice.milliSeconds = convertOnDurationTimerMilliSecondsValueToEnum(ueCb->duMacUeCfg.\
7533       macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationtimerValue.milliSeconds);
7534    }
7535    else
7536    {
7537       drxCfg->choice.setup->drx_onDurationTimer.present = DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds;
7538       drxCfg->choice.setup->drx_onDurationTimer.choice.subMilliSeconds = ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.\
7539       drxOnDurationTimer.onDurationtimerValue.subMilliSeconds;
7540    }
7541    drxCfg->choice.setup->drx_InactivityTimer = convertDrxInactivityTimerValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxInactivityTimer);
7542    drxCfg->choice.setup->drx_HARQ_RTT_TimerDL = ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxHarqRttTimerDl;
7543    drxCfg->choice.setup->drx_HARQ_RTT_TimerUL = ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxHarqRttTimerUl;
7544    drxCfg->choice.setup->drx_RetransmissionTimerDL = convertDrxRetransmissionTimerDlValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.\
7545    drxRetransmissionTimerDl);
7546    drxCfg->choice.setup->drx_RetransmissionTimerUL = convertDrxRetransmissionTimerUlValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.\
7547    drxRetransmissionTimerUl);
7548    drxCfg->choice.setup->drx_SlotOffset = ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxSlotOffset;
7549    fillLongCycleOffsetValFromDuCb(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxLongCycleStartOffset, &drxCfg->choice.setup->drx_LongCycleStartOffset);
7550
7551    if(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.shortDrxPres)
7552    {
7553       DU_ALLOC(drxCfg->choice.setup->shortDRX, sizeof(struct DRX_ConfigRrc__shortDRX));
7554       if(drxCfg->choice.setup->shortDRX)
7555       {
7556          drxCfg->choice.setup->shortDRX->drx_ShortCycle = convertShortDrxCycleLengthValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.\
7557          shortDrx.drxShortCycle);
7558          drxCfg->choice.setup->shortDRX->drx_ShortCycleTimer = ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.shortDrx.drxShortCycleTimer;
7559       }
7560       else
7561       {
7562          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDrxConfigRrc");
7563          return RFAILED;
7564       }
7565    }
7566    return ROK;
7567 }
7568 #endif
7569 /*******************************************************************
7570  *
7571  * @brief Builds Mac cell group config
7572  *
7573  * @details
7574  *
7575  *    Function : BuildMacCellGrpCfg
7576  *
7577  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
7578  *
7579  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
7580  *
7581  * @return ROK     - success
7582  *         RFAILED - failure
7583  *
7584  * ****************************************************************/
7585 uint8_t BuildMacCellGrpCfg(DuUeCb *ueCb, MAC_CellGroupConfig_t *macCellGrpCfg)
7586 {
7587    macCellGrpCfg->drx_ConfigRrc = NULLP;
7588 #ifdef NR_DRX
7589    if(ueCb)
7590    {
7591       DU_ALLOC(macCellGrpCfg->drx_ConfigRrc, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
7592       if(!macCellGrpCfg->drx_ConfigRrc)
7593       {
7594          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7595          return RFAILED;
7596       }
7597       if(BuildDrxConfigRrc(ueCb, macCellGrpCfg->drx_ConfigRrc) != ROK)
7598       {
7599          DU_LOG("\nERROR  -->  F1AP : failed to build drx config");
7600          return RFAILED;
7601       }
7602    }
7603 #endif
7604    macCellGrpCfg->schedulingRequestConfig = NULLP;
7605    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
7606    if(!macCellGrpCfg->schedulingRequestConfig)
7607    {
7608       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7609       return RFAILED;
7610    }
7611
7612    if(BuildSchedulingReqConfig(ueCb, macCellGrpCfg->schedulingRequestConfig) != ROK)
7613    {
7614       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
7615       return RFAILED;
7616    }
7617
7618    macCellGrpCfg->bsr_Config = NULLP;
7619    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
7620    if(!macCellGrpCfg->bsr_Config)
7621    {
7622       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7623       return RFAILED;
7624    }
7625
7626    if(BuildBsrConfig(ueCb, macCellGrpCfg->bsr_Config) != ROK)
7627    {
7628       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
7629       return RFAILED;
7630    }
7631
7632    macCellGrpCfg->tag_Config = NULLP;
7633    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
7634    if(!macCellGrpCfg->tag_Config)
7635    {
7636       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7637       return RFAILED;
7638    }
7639
7640    if(BuildTagConfig(ueCb, macCellGrpCfg->tag_Config) != ROK)
7641    {
7642       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
7643       return RFAILED;
7644    }
7645
7646    macCellGrpCfg->phr_Config = NULLP;
7647    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
7648    if(!macCellGrpCfg->phr_Config)
7649    {
7650       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7651       return RFAILED;
7652    }
7653
7654    if(BuildPhrConfig(ueCb, macCellGrpCfg->phr_Config) != ROK)
7655    {
7656       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
7657       return RFAILED;
7658    }
7659
7660    macCellGrpCfg->skipUplinkTxDynamic = false;
7661    macCellGrpCfg->ext1 = NULLP;
7662
7663    return ROK;
7664 }
7665 /*******************************************************************
7666  *
7667  * @brief Frees memeory allocated for SearchSpcToAddModList
7668  *
7669  * @details
7670  *
7671  *    Function : FreeSearchSpcToAddModList
7672  *
7673  *    Functionality: Deallocating memory of SearchSpcToAddModList
7674  *
7675  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
7676  *
7677  * @return void
7678  *
7679  4221 * ****************************************************************/
7680 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
7681 {
7682    uint8_t idx1=0;
7683    uint8_t idx2=0;
7684    struct  SearchSpace *searchSpc=NULLP;
7685
7686    if(searchSpcList->list.array)
7687    {
7688       if(searchSpcList->list.array[idx2])
7689       {
7690          searchSpc = searchSpcList->list.array[idx2];
7691          if(searchSpc->controlResourceSetId)
7692          {
7693             if(searchSpc->monitoringSlotPeriodicityAndOffset)
7694             {
7695                if(searchSpc->monitoringSymbolsWithinSlot)
7696                {
7697                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
7698                   {
7699                      if(searchSpc->nrofCandidates)
7700                      {
7701                         if(searchSpc->searchSpaceType)
7702                         {
7703                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
7704                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
7705                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
7706                                     SearchSpace__searchSpaceType));
7707                         }
7708                         DU_FREE(searchSpc->nrofCandidates,
7709                               sizeof(struct SearchSpace__nrofCandidates));
7710                      }
7711                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
7712                            searchSpc->monitoringSymbolsWithinSlot->size);
7713                   }
7714                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
7715                         sizeof(BIT_STRING_t));
7716                }
7717                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
7718                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
7719             }
7720             DU_FREE(searchSpc->controlResourceSetId,
7721                   sizeof(ControlResourceSetId_t));
7722          }
7723       }
7724       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
7725       {
7726          DU_FREE(searchSpcList->list.array[idx1],
7727                sizeof(struct SearchSpace));
7728       }
7729       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
7730    }
7731 }
7732 /*******************************************************************
7733  *
7734  * @brief Frees memory allocated for PdschTimeDomAllocList
7735  *
7736  * @details
7737  *
7738  *    Function : FreePdschTimeDomAllocList
7739  *
7740  *    Functionality: Deallocating memory of PdschTimeDomAllocList
7741  *
7742  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
7743  *
7744  * @return void
7745  *
7746  * ****************************************************************/
7747 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
7748 {
7749    uint8_t idx1=0;
7750
7751    if(timeDomAllocList->choice.setup)
7752    {
7753       if(timeDomAllocList->choice.setup->list.array)
7754       {
7755          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
7756          {
7757             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
7758             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
7759                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
7760          }
7761          DU_FREE(timeDomAllocList->choice.setup->list.array, \
7762                timeDomAllocList->choice.setup->list.size);
7763       }
7764       DU_FREE(timeDomAllocList->choice.setup,\
7765             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
7766    }
7767 }
7768 /*******************************************************************
7769  *
7770  * @brief Frees memory allocated for PuschTimeDomAllocList
7771  *
7772  *@details
7773  *
7774  *    Function : FreePuschTimeDomAllocList
7775  *
7776  *    Functionality: Deallocating memory of PuschTimeDomAllocList
7777  *
7778  * @params[in] PUSCH_Config_t *puschCfg
7779  *
7780  * @return void
7781  *
7782  * ****************************************************************/
7783 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
7784 {
7785    uint8_t rsrcListIdx=0;
7786    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7787
7788    if(puschCfg->pusch_TimeDomainAllocationList)
7789    {
7790       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7791       if(timeDomAllocList_t->choice.setup)
7792       {
7793          if(timeDomAllocList_t->choice.setup->list.array)
7794          {
7795             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
7796             {
7797                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
7798                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
7799                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
7800             }
7801             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
7802                   timeDomAllocList_t->choice.setup->list.size);
7803          }
7804          DU_FREE(timeDomAllocList_t->choice.setup, \
7805                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
7806       }
7807       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
7808       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
7809             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
7810    }
7811
7812 }
7813
7814 /*******************************************************************
7815  *
7816  * @brief Frees memory allocated for Dedicated PUCCH config
7817  *
7818  * @details
7819  *
7820  *    Function : FreeBWPUlDedPucchCfg
7821  *
7822  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
7823  *
7824  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
7825  *
7826  * @return void
7827  *
7828  * ****************************************************************/
7829 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
7830 {
7831    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
7832    PUCCH_Config_t *pucchCfg = NULLP;
7833    PUCCH_ResourceSet_t *rsrcSet = NULLP;
7834    PUCCH_Resource_t *rsrc = NULLP;
7835
7836    if(ulBwpPucchCfg)
7837    {
7838       if(ulBwpPucchCfg->choice.setup)
7839       {
7840          pucchCfg = ulBwpPucchCfg->choice.setup;
7841
7842          //Free resource set list
7843          if(pucchCfg->resourceSetToAddModList)
7844          {
7845             if(pucchCfg->resourceSetToAddModList->list.array)
7846             {
7847                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
7848                {
7849                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
7850                   if(rsrcSet->resourceList.list.array)
7851                   {
7852                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
7853                      {
7854                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
7855                      }
7856                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
7857                   }
7858                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
7859                }
7860                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
7861             }
7862             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
7863          }
7864
7865          //Free resource list
7866          if(pucchCfg->resourceToAddModList)
7867          {
7868             if(pucchCfg->resourceToAddModList->list.array)
7869             {
7870                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
7871                {
7872                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
7873                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
7874                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
7875                }
7876                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
7877             }
7878             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
7879          }
7880
7881          //PUCCH Format 1
7882          if(pucchCfg->format1)
7883          {
7884             if(pucchCfg->format1->choice.setup)
7885             {
7886                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
7887                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
7888             }
7889             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
7890          }
7891
7892          //DL DATA TO UL ACK
7893          if(pucchCfg->dl_DataToUL_ACK)
7894          {
7895             if(pucchCfg->dl_DataToUL_ACK->list.array)
7896             {
7897                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
7898                {
7899                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
7900                }
7901                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
7902             }
7903             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
7904          }
7905
7906          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
7907       }
7908       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
7909    }
7910 }
7911
7912 /*******************************************************************
7913  *
7914  * @brief Frees memory allocated for InitialUlBWP
7915  *
7916  * @details
7917  *
7918  *    Function : FreeInitialUlBWP
7919  *
7920  *    Functionality: Deallocating memory of InitialUlBWP
7921  *
7922  * @params[in] BWP_UplinkDedicated_t *ulBwp
7923  *
7924  * @return void
7925  *
7926  * ****************************************************************/
7927 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
7928 {
7929    uint8_t  rSetIdx, rsrcIdx;
7930    SRS_Config_t   *srsCfg = NULLP;
7931    PUSCH_Config_t *puschCfg = NULLP;
7932    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
7933    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
7934    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
7935    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
7936
7937    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
7938
7939    if(ulBwp->pusch_Config)
7940    {
7941       if(ulBwp->pusch_Config->choice.setup)
7942       {
7943          puschCfg=ulBwp->pusch_Config->choice.setup;
7944          if(puschCfg->dataScramblingIdentityPUSCH)
7945          {
7946             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
7947             {
7948                FreePuschTimeDomAllocList(puschCfg);
7949                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
7950                if(dmrsUlCfg->choice.setup)
7951                {
7952                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
7953                   {
7954                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
7955                      {
7956                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
7957                               sizeof(long));
7958                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
7959                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
7960                      }
7961                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
7962                            sizeof(long));
7963                   }
7964                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
7965                }
7966                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
7967                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
7968             }
7969             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
7970          }
7971          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
7972       }
7973       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
7974
7975       /* Free SRS-Config */
7976       if(ulBwp->srs_Config)
7977       {
7978          if(ulBwp->srs_Config->choice.setup)
7979          {
7980             srsCfg = ulBwp->srs_Config->choice.setup;
7981
7982             /* Free Resource Set to add/mod list */
7983             if(srsCfg->srs_ResourceSetToAddModList)
7984             {
7985                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
7986                if(rsrcSetList->list.array)
7987                {
7988                   rSetIdx = 0;
7989
7990                   /* Free SRS resource Id list in this SRS resource set */
7991                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
7992                   {
7993                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
7994
7995                      if(rsrcIdList->list.array)
7996                      {
7997                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
7998                         {
7999                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
8000                         }
8001                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
8002                      }
8003                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
8004                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
8005                   }
8006
8007                   /* Free resource type info for this SRS resource set */
8008                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
8009                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
8010
8011                   /* Free memory for each resource set */
8012                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
8013                   {
8014                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
8015                   }
8016                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
8017                }
8018                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
8019                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
8020             }
8021
8022             /* Free resource to add/modd list */
8023             if(srsCfg->srs_ResourceToAddModList)
8024             {
8025                resourceList = srsCfg->srs_ResourceToAddModList;
8026                if(resourceList->list.array)
8027                {
8028                   rsrcIdx = 0;
8029                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
8030                         sizeof(struct SRS_Resource__transmissionComb__n2));
8031                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
8032                         sizeof(struct SRS_Resource__resourceType__aperiodic));
8033
8034                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
8035                   {
8036                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
8037                   }
8038                   DU_FREE(resourceList->list.array, resourceList->list.size);
8039                }
8040                DU_FREE(srsCfg->srs_ResourceToAddModList, \
8041                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
8042             }
8043
8044             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
8045          }
8046          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
8047       }
8048    }
8049 }
8050 /*******************************************************************
8051  *
8052  * @brief Frees memory allocated for initialUplinkBWP
8053  *
8054  * @details
8055  *
8056  *    Function : FreeinitialUplinkBWP
8057  *
8058  *    Functionality: Deallocating memory of initialUplinkBWP
8059  *
8060  * @params[in] UplinkConfig_t *ulCfg
8061  *
8062  * @return void
8063  *
8064  *
8065  * ****************************************************************/
8066 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
8067 {
8068    BWP_UplinkDedicated_t *ulBwp=NULLP;
8069    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
8070
8071    if(ulCfg->initialUplinkBWP)
8072    {
8073       ulBwp=ulCfg->initialUplinkBWP;
8074       if(ulCfg->firstActiveUplinkBWP_Id)
8075       {
8076          if(ulCfg->pusch_ServingCellConfig)
8077          {
8078             puschCfg=ulCfg->pusch_ServingCellConfig;
8079             if(puschCfg->choice.setup)
8080             {
8081                if(puschCfg->choice.setup->ext1)
8082                {
8083                   DU_FREE(puschCfg->choice.setup->ext1->\
8084                         processingType2Enabled,sizeof(BOOLEAN_t));
8085                   DU_FREE(puschCfg->choice.setup->ext1->\
8086                         maxMIMO_Layers,sizeof(long));
8087                   DU_FREE(puschCfg->choice.setup->ext1, \
8088                         sizeof(struct PUSCH_ServingCellConfig__ext1));
8089                }
8090                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
8091             }
8092             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
8093          }
8094          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
8095       }
8096       FreeInitialUlBWP(ulBwp);
8097       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
8098    }
8099 }
8100 /*******************************************************************
8101  *
8102  * @brief Frees emmory allocated for BWPDlDedPdschCfg
8103  *
8104  * @details
8105  *
8106  *    Function : FreeBWPDlDedPdschCfg
8107  *
8108  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
8109  *
8110  * @params[in] BWP_DownlinkDedicated_t *dlBwp
8111  *
8112  * @return void
8113  *
8114  *
8115  * ****************************************************************/
8116 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
8117 {
8118    struct PDSCH_Config *pdschCfg=NULLP;
8119    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
8120    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
8121    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
8122
8123    if(dlBwp->pdsch_Config->choice.setup)
8124    {
8125       pdschCfg=dlBwp->pdsch_Config->choice.setup;
8126       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8127       {
8128          if(pdschCfg->pdsch_TimeDomainAllocationList)
8129          {
8130             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
8131             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
8132             {
8133                prbBndlType=&pdschCfg->prb_BundlingType;
8134                DU_FREE(prbBndlType->choice.staticBundling,\
8135                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
8136                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
8137             }
8138             FreePdschTimeDomAllocList(timeDomAllocList);
8139             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
8140                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
8141          }
8142          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
8143          if(dmrsDlCfg->choice.setup)
8144          {
8145             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
8146                   sizeof(long));
8147             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
8148          }
8149          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
8150                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
8151       }
8152       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
8153    }
8154 }
8155 /*******************************************************************
8156  *
8157  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
8158  *
8159  * @details
8160  *
8161  *    Function : FreeBWPDlDedPdcchCfg
8162  *
8163  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
8164  *
8165  * @params[in] BWP_DownlinkDedicated_t *dlBwp
8166  *
8167  * @return void
8168  *
8169  *
8170  * ****************************************************************/
8171 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
8172 {
8173    uint8_t idx1=0;
8174    uint8_t idx2=0;
8175    struct PDCCH_Config *pdcchCfg=NULLP;
8176    struct ControlResourceSet *controlRSet=NULLP;
8177    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
8178
8179    if(dlBwp->pdcch_Config->choice.setup)
8180    {
8181       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
8182       if(pdcchCfg->controlResourceSetToAddModList)
8183       {
8184          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
8185          if(controlRSetList->list.array)
8186          {
8187             controlRSet = controlRSetList->list.array[idx2];
8188             if(controlRSet)
8189             {
8190                if(controlRSet->frequencyDomainResources.buf)
8191                {
8192                   if(controlRSet->pdcch_DMRS_ScramblingID)
8193                   {
8194                      if(pdcchCfg->searchSpacesToAddModList)
8195                      {
8196                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
8197                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
8198                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
8199                      }
8200                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
8201                   }
8202                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
8203                         controlRSet->frequencyDomainResources.size);
8204                }
8205             }
8206             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
8207             {
8208                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
8209             }
8210             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
8211          }
8212          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
8213                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
8214       }
8215       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
8216    }
8217 }
8218
8219 /*******************************************************************
8220  *
8221  * @brief Free SCS specific carrier list in DL frequency info
8222  *
8223  * @details
8224  *
8225  *    Function : FreeScsSpecificCarrierListDl
8226  *
8227  *    Functionality: Free SCS specific carrier list in DL frequency info
8228  *
8229  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
8230  *
8231  * @return void
8232  *
8233  * ****************************************************************/
8234 void FreeScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
8235 {
8236    uint8_t listIdx = 0;
8237
8238    if(!scsCarrierList->list.array)
8239    {
8240       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
8241       {
8242          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
8243       }
8244       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
8245    }
8246 }
8247
8248 /*******************************************************************
8249  *
8250  * @brief Free DL frequency info in DL config common
8251  *
8252  * @details
8253  *
8254  *    Function : FreeFreqInfoDl
8255  *
8256  *    Functionality: Free DL frequency info in DL config common
8257  *
8258  * @params[in] Pointer to DownlinkConfigCommon_t
8259  *
8260  * @return void
8261  *
8262  * ****************************************************************/
8263 void FreeFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
8264 {
8265    uint8_t freqBandIdx = 0;
8266
8267    /* SSB Absolute Frequency */
8268    DU_FREE(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
8269
8270    /* NR Multi Frequency Band List */
8271    if(frequencyInfoDL->frequencyBandList.list.array)
8272    {
8273       for(freqBandIdx = 0; freqBandIdx < frequencyInfoDL->frequencyBandList.list.count; freqBandIdx++)
8274       {
8275          DU_FREE(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
8276       }
8277       DU_FREE(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
8278    }
8279
8280    /* Subcarrier Spacing specifc carrier List */
8281    FreeScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList);
8282 }
8283
8284 /*******************************************************************
8285  *
8286  * @brief Free DL config common in Serving cell config common
8287  *
8288  * @details
8289  *
8290  *    Function : FreeDlConfigCommon
8291  *
8292  *    Functionality: Free DL config common in Serving cell config common
8293  *
8294  * @params[in] Pointer to DownlinkConfigCommon_t
8295  *
8296  * @return void
8297  *
8298  * ****************************************************************/
8299 void FreeDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
8300 {
8301    /* DL Frequency Info */
8302    if(dlCfgCommon->frequencyInfoDL)
8303    {
8304       FreeFreqInfoDl(dlCfgCommon->frequencyInfoDL);
8305       DU_FREE(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
8306    }
8307
8308    /* DL BWP config common */
8309    if(dlCfgCommon->initialDownlinkBWP)
8310    {
8311       FreeBwpDlCommon(dlCfgCommon->initialDownlinkBWP);
8312       DU_FREE(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
8313    }
8314 }
8315
8316 /*******************************************************************
8317  *
8318  * @brief Free SCS specific carrier list in UL frequency Info
8319  *
8320  * @details
8321  *
8322  *    Function : FreeScsSpecificCarrierListUl
8323  *
8324  *    Functionality: Free SCS specific carrier list in UL frequency Info
8325  *
8326  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
8327  *
8328  * @return void
8329  *
8330  * ****************************************************************/
8331 void FreeScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
8332 {
8333    uint8_t listIdx = 0;
8334
8335    if(scsCarrierList->list.array)
8336    {
8337       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
8338       {
8339          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
8340       }
8341       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
8342    }
8343 }
8344
8345 /*******************************************************************
8346  *
8347  * @brief Free frequency info in UL config common
8348  *
8349  * @details
8350  *
8351  *    Function : FreeFreqInfoUl
8352  *
8353  *    Functionality: Free frequency info in UL config common
8354  *
8355  * @params[in] Pointer to FrequencyInfoUL_t
8356  *
8357  * @return void
8358  *
8359  * ****************************************************************/
8360 void FreeFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
8361 {
8362    uint8_t listIdx= 0;
8363
8364    /* NR Multi Frequency Band List */
8365    if(!frequencyInfoUL->frequencyBandList)
8366    {
8367       if(frequencyInfoUL->frequencyBandList->list.array)
8368       {
8369          for(listIdx = 0; listIdx < frequencyInfoUL->frequencyBandList->list.count; listIdx++)
8370          {
8371             DU_FREE(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
8372          }
8373          DU_FREE(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
8374       }
8375       DU_FREE(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
8376    }
8377
8378    /* Absolute frequency point A */
8379    DU_FREE(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
8380
8381    /* Subcarrier Spacing specifc carrier */
8382    FreeScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList);
8383
8384    /* P-MAX */
8385    DU_FREE(frequencyInfoUL->p_Max, sizeof(P_Max_t));
8386 }
8387
8388 /*******************************************************************
8389  *
8390  * @brief Free UL config common in Serving cell config common
8391  *
8392  * @details
8393  *
8394  *    Function : FreeUlConfigCommon
8395  *
8396  *    Functionality: Free UL config common in Serving cell config common
8397  *
8398  * @params[in] Pointer to UplinkConfigCommon_t
8399  *
8400  * @return void
8401  *
8402  * ****************************************************************/
8403 void FreeUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
8404 {
8405    /* UL Frequency Info */
8406    if(ulCfgCommon->frequencyInfoUL)
8407    {
8408       FreeFreqInfoUl(ulCfgCommon->frequencyInfoUL);
8409       DU_FREE(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
8410    }
8411
8412    /* UL BWP common */
8413    if(ulCfgCommon->initialUplinkBWP)
8414    {
8415       FreeBwpUlCommon(ulCfgCommon->initialUplinkBWP);
8416       DU_FREE(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
8417    }
8418 }
8419
8420 /*******************************************************************
8421  *
8422  * @brief Free SP cell config common in Reconfig with Sync
8423  *
8424  * @details
8425  *
8426  *    Function : FreeSpCellConfigCommon
8427  *
8428  *    Functionality: Free SP cell config common in Reconfig with Sync
8429  *
8430  * @params[in] Pointer to ServingCellConfigCommon_t
8431  *
8432  * @return void
8433  *
8434  * ****************************************************************/
8435 void FreeSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
8436 {
8437    /* Free Physical cell identity */
8438    DU_FREE(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
8439
8440    /* Free Downlink Config common */
8441    if(spCellConfigCommon->downlinkConfigCommon)
8442    {
8443       FreeDlConfigCommon(spCellConfigCommon->downlinkConfigCommon);
8444       DU_FREE(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
8445    }
8446
8447    /* Free Uplink Config common */
8448    if(spCellConfigCommon->uplinkConfigCommon)
8449    {
8450       FreeUlConfigCommon(spCellConfigCommon->uplinkConfigCommon);
8451       DU_FREE(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
8452    }
8453
8454    /* Free Timing Advance offset */
8455    DU_FREE(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
8456
8457    /* Free SSB Position in Burst */
8458    if(spCellConfigCommon->ssb_PositionsInBurst)
8459    {
8460       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.buf, \
8461          spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.size);
8462       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
8463    }
8464
8465    /* Free SSB Periodicity in Serving cell */
8466    DU_FREE(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
8467
8468    /* Free SSB subcarrier spacing */
8469    DU_FREE(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8470
8471    /* TDD UL-DL configuration common */
8472    DU_FREE(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
8473 }
8474
8475 /*******************************************************************
8476  *
8477  * @brief Free dedicated RACH configuration in Reconfiguration with sync
8478  *
8479  * @details
8480  *
8481  *    Function : FreeRecfgWithSync
8482  *
8483  *    Functionality:
8484  *       Free dedicated RACH configuration in Reconfiguration with sync
8485  *
8486  * @params[in] Pinter to Rach config dedicated struct
8487  *
8488  * @return void
8489  *
8490  * ****************************************************************/
8491 void FreeRachConfigDedicated(struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
8492 {
8493    uint8_t listIdx = 0;
8494    CFRA_t *cfra = NULLP;
8495    struct CFRA__resources__ssb *ssbResource = NULLP;
8496
8497    /* Uplink */
8498    if(rachCfgDed->choice.uplink)
8499    {
8500       /* CFRA : Contention free Random Access */
8501       if(rachCfgDed->choice.uplink->cfra)
8502       {
8503          cfra = rachCfgDed->choice.uplink->cfra;
8504
8505          /* CFRA occassions */
8506          if(cfra->occasions)
8507          {
8508             /* CFRA occassions : SSB per RACH occasion */
8509             DU_FREE(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
8510             DU_FREE(cfra->occasions, sizeof(struct CFRA__occasions));
8511          }
8512
8513          /* CFRA resource */
8514          cfra->resources.present = CFRA__resources_PR_ssb;
8515
8516          /* CFRA resource : SSB */
8517          if(cfra->resources.choice.ssb)
8518          {
8519             ssbResource = cfra->resources.choice.ssb;
8520
8521             /* CFRA SSB resource list */
8522             if(ssbResource->ssb_ResourceList.list.array)
8523             {
8524                for(listIdx = 0; listIdx < ssbResource->ssb_ResourceList.list.count; listIdx++)
8525                {
8526                   DU_FREE(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
8527                }
8528                DU_FREE(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
8529             }
8530             DU_FREE(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
8531          }
8532          DU_FREE(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
8533       }
8534       DU_FREE(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
8535    }
8536 }
8537
8538 /*******************************************************************
8539  *
8540  * @brief Frees reconfiguration with sync in SP cell config
8541  *
8542  * @details
8543  *
8544  *    Function : FreeRecfgWithSync
8545  *
8546  *    Functionality: Fress reconfiguration with sync in SP cell config
8547  *
8548  * @params[in] Pointer to ReconfigurationWithSync_t
8549  *
8550  * @return void
8551  *
8552  * ****************************************************************/
8553 void FreeRecfgWithSync(ReconfigurationWithSync_t *recfgWithSync)
8554 {
8555    /* Free SP Cell config common */
8556    if(recfgWithSync->spCellConfigCommon)
8557    {
8558       FreeSpCellConfigCommon(recfgWithSync->spCellConfigCommon);
8559       DU_FREE(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
8560    }
8561
8562    /* Free Dedicated RACH configuration */
8563    if(recfgWithSync->rach_ConfigDedicated)
8564    {
8565       FreeRachConfigDedicated(recfgWithSync->rach_ConfigDedicated);
8566       DU_FREE(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
8567    }
8568 }
8569
8570 /*******************************************************************
8571  *
8572  * @brief Frees emmory allocated for DUToCURRCContainer
8573  *
8574  * @details
8575  *
8576  *    Function : FreeMemDuToCuRrcCont
8577  *
8578  *    Functionality: Deallocating memory of DuToCuRrcContainer
8579  *
8580  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
8581  *
8582  * @return ROK     - success
8583  *         RFAILED - failure
8584  *
8585  * ****************************************************************/
8586 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
8587 {
8588    uint8_t idx=0;
8589    SpCellConfig_t *spCellCfg=NULLP;
8590    ServingCellConfig_t *srvCellCfg=NULLP;
8591    BWP_DownlinkDedicated_t *dlBwp=NULLP;
8592    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
8593    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
8594    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
8595    struct RLC_Config *rlcConfig=NULLP;
8596    struct LogicalChannelConfig *macLcConfig=NULLP;
8597    struct MAC_CellGroupConfig__drx_ConfigRrc *drxCfg=NULLP;
8598    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
8599    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
8600    struct TAG_Config *tagConfig=NULLP;
8601    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
8602    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
8603    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
8604
8605    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
8606    if(rlcBearerList)
8607    {
8608       if(rlcBearerList->list.array)
8609       {
8610          for(idx=0; idx<rlcBearerList->list.count; idx++)
8611          {
8612             if(rlcBearerList->list.array[idx])
8613             {
8614                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
8615                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
8616                if(rlcConfig)
8617                {
8618                   switch(rlcConfig->present)
8619                   {
8620                      case RLC_Config_PR_NOTHING:
8621                         break;
8622
8623                      case RLC_Config_PR_am:
8624                         {
8625                            if(rlcConfig->choice.am)
8626                            {
8627                               DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8628                               DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8629                               DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
8630                            }
8631                            break;
8632                         }
8633                      case RLC_Config_PR_um_Bi_Directional:
8634                         {
8635                            if(rlcConfig->choice.um_Bi_Directional)
8636                            {
8637                               DU_FREE(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8638                               DU_FREE(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8639                               DU_FREE(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
8640                            }
8641                            break;
8642                         }
8643                      case RLC_Config_PR_um_Uni_Directional_UL:
8644                         {
8645                            if(rlcConfig->choice.um_Uni_Directional_UL)
8646                            {
8647                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8648                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
8649                            }
8650                            break;
8651                         }
8652                      case RLC_Config_PR_um_Uni_Directional_DL:
8653                         {
8654                            if(rlcConfig->choice.um_Uni_Directional_DL )
8655                            {
8656                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8657                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
8658                            }
8659                            break;
8660                         }
8661                   }
8662                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
8663                }
8664                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
8665                if(macLcConfig)
8666                {
8667                   if(macLcConfig->ul_SpecificParameters)
8668                   {
8669                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
8670                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
8671                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
8672                   }
8673                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
8674                }
8675                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
8676             }
8677          }
8678          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
8679       }
8680       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8681    }
8682
8683    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
8684    if(macCellGrpCfg)
8685    {
8686       drxCfg = macCellGrpCfg->drx_ConfigRrc;
8687
8688       if(drxCfg)
8689       {
8690           switch(drxCfg->present)
8691           {
8692             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
8693                break;
8694             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
8695             {
8696                if(drxCfg->choice.setup)
8697                {
8698                   DU_FREE(drxCfg->choice.setup->shortDRX, sizeof(struct DRX_ConfigRrc__shortDRX));
8699                   DU_FREE(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
8700                }
8701             }
8702             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
8703                break;
8704           }
8705           DU_FREE(drxCfg, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
8706       }
8707       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
8708       if(schedulingRequestConfig)
8709       {
8710          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
8711          if(schReqList)
8712          {
8713             if(schReqList->list.array)
8714             {
8715                for(idx=0;idx<schReqList->list.count; idx++)
8716                {
8717                   if(schReqList->list.array[idx])
8718                   {
8719                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
8720                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
8721                   }
8722                }
8723                DU_FREE(schReqList->list.array, schReqList->list.size);
8724             }
8725             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
8726                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
8727             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
8728       }
8729       if(macCellGrpCfg->bsr_Config)
8730       {
8731          DU_FREE(macCellGrpCfg->bsr_Config->logicalChannelSR_DelayTimer, sizeof(long));
8732          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
8733       }
8734       tagConfig = macCellGrpCfg->tag_Config;
8735       if(tagConfig)
8736       {
8737          tagList = tagConfig->tag_ToAddModList;
8738          if(tagList)
8739          {
8740             if(tagList->list.array)
8741             {
8742                for(idx=0; idx<tagList->list.count; idx++)
8743                {
8744                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
8745                }
8746                DU_FREE(tagList->list.array, tagList->list.size);
8747             }
8748             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
8749          }
8750          DU_FREE(tagConfig, sizeof(struct TAG_Config));
8751       }
8752
8753       phrConfig = macCellGrpCfg->phr_Config;
8754       if(phrConfig)
8755       {
8756          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
8757          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
8758       }
8759
8760       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
8761    }
8762
8763    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
8764    if(phyCellGrpCfg)
8765    {
8766       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
8767       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
8768    }
8769
8770    spCellCfg = cellGrpCfg->spCellConfig;
8771    if(spCellCfg)
8772    {
8773       /* Free serving cell index */
8774       DU_FREE(spCellCfg->servCellIndex, sizeof(long));
8775
8776       /* Free Reconfiguration with sync */
8777       if(spCellCfg->reconfigurationWithSync)
8778       {
8779          FreeRecfgWithSync(spCellCfg->reconfigurationWithSync);
8780          DU_FREE(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
8781       }
8782
8783       /* Free rlmInSyncOutOfSyncThreshold */
8784       DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
8785
8786       /* Free SP Cell config dedicated */
8787       if(spCellCfg->spCellConfigDedicated)
8788       {
8789          srvCellCfg = spCellCfg->spCellConfigDedicated;
8790
8791          /* Free TDD UL-DL config dedicated */
8792          DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
8793
8794          /* Free Initial Downlink BWP */
8795          if(srvCellCfg->initialDownlinkBWP)
8796          {
8797             dlBwp = srvCellCfg->initialDownlinkBWP;
8798
8799             /* Free DL BWP PDCCH Config */
8800             if(dlBwp->pdcch_Config)
8801             {
8802                FreeBWPDlDedPdcchCfg(dlBwp);
8803                DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
8804             }
8805
8806             /* Free DL BWP PDSCH config */
8807             if(dlBwp->pdsch_Config)
8808             {
8809                FreeBWPDlDedPdschCfg(dlBwp);
8810                DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
8811             }
8812             DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
8813          }
8814
8815          /* Free First Active Downlink BWP */
8816          DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
8817
8818          /* Free Default downlink BWP */
8819          DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
8820
8821          /* Free Uplink config */
8822          if(srvCellCfg->uplinkConfig)
8823          {
8824             FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
8825             DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
8826          }
8827
8828          /* Free PDSCH serving cell config */
8829          if(srvCellCfg->pdsch_ServingCellConfig)
8830          {
8831             pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
8832             if(pdschCfg->choice.setup)
8833             {
8834                DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
8835                DU_FREE(pdschCfg->choice.setup, sizeof(struct PDSCH_ServingCellConfig));
8836             }
8837             DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
8838          }
8839
8840          DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
8841       }
8842       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
8843    }
8844    return ROK;
8845 }
8846
8847 /*******************************************************************
8848  *
8849  * @brief Builds CellGroupConfigRrc for DU To CU RRC Container
8850  *
8851  * @details
8852  *
8853  *    Function : BuildCellGroupConfigRrc
8854  *
8855  *    Functionality: Builds and copied Cell group config buffer into
8856  *       DuToCuRrcContainer
8857  *
8858  * @params[in] idx, index in F1AP msg
8859  *             DuToCuRRCContainer, DuToCuRRCContainer
8860  *
8861  * @return ROK     - success
8862  *         RFAILED - failure
8863  *
8864  * ****************************************************************/
8865 uint8_t BuildCellGroupConfigRrc(DuUeCb *ueCb, OCTET_STRING_t *duToCuRrcContainer)
8866 {
8867    uint8_t  ret = ROK;
8868    CellGroupConfigRrc_t  cellGrpCfg;
8869    asn_enc_rval_t        encRetVal;
8870    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
8871    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8872
8873    while(true)
8874    {
8875       cellGrpCfg.cellGroupId = CELL_GRP_ID;
8876
8877       cellGrpCfg.rlc_BearerToAddModList = NULLP;
8878       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8879       if(!cellGrpCfg.rlc_BearerToAddModList)
8880       {
8881          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8882          ret = RFAILED;
8883          break;
8884       }
8885       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList) != ROK)
8886       {
8887          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
8888          ret = RFAILED;
8889          break;
8890       }
8891
8892       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
8893       cellGrpCfg.mac_CellGroupConfig = NULLP;
8894       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
8895       if(!cellGrpCfg.mac_CellGroupConfig)
8896       {
8897          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8898          ret = RFAILED;
8899          break;
8900       }
8901       if(BuildMacCellGrpCfg(ueCb, cellGrpCfg.mac_CellGroupConfig) != ROK)
8902       {
8903          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
8904          ret = RFAILED;
8905          break;
8906       }
8907
8908       cellGrpCfg.physicalCellGroupConfig = NULLP;
8909       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
8910       if(!cellGrpCfg.physicalCellGroupConfig)
8911       {
8912          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8913          ret = RFAILED;
8914          break;
8915       }
8916       if(BuildPhyCellGrpCfg(ueCb, cellGrpCfg.physicalCellGroupConfig) != ROK)
8917       {
8918          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
8919          ret = RFAILED;
8920          break;
8921       }
8922
8923       cellGrpCfg.spCellConfig = NULLP;
8924       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
8925       if(!cellGrpCfg.spCellConfig)
8926       {
8927          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8928          ret = RFAILED;
8929          break;
8930       }
8931       if(BuildSpCellCfg(ueCb, cellGrpCfg.spCellConfig) != ROK)
8932       {
8933          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
8934          ret = RFAILED;
8935          break;
8936       }
8937
8938       cellGrpCfg.sCellToAddModList = NULLP;
8939       cellGrpCfg.sCellToReleaseList = NULLP;
8940       cellGrpCfg.ext1 = NULLP;
8941
8942       /* encode cellGrpCfg into duToCuRrcContainer */
8943       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
8944       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8945       encBufSize = 0;
8946       encRetVal = uper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
8947       /* Encode results */
8948       if(encRetVal.encoded == ENCODE_FAIL)
8949       {
8950          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
8951                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8952          ret = RFAILED;
8953          break;
8954       }
8955       else
8956       {
8957          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
8958 #ifdef DEBUG_ASN_PRINT
8959          for(int i=0; i< encBufSize; i++)
8960          {
8961             printf("%x",encBuf[i]);
8962          }
8963 #endif
8964       }
8965
8966       duToCuRrcContainer->size = encBufSize;
8967       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
8968       if(!duToCuRrcContainer->buf)
8969       {
8970          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
8971          ret = RFAILED;
8972          break;
8973       }
8974       if(ret == ROK)
8975       {
8976          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
8977       }
8978       break;
8979    }
8980    FreeMemDuToCuRrcCont(&cellGrpCfg);
8981    return ret;
8982 }
8983
8984 /*******************************************************************
8985  *
8986  * @brief Free memory allocated in InitialULRRCMessage
8987  *
8988  * @details
8989  *
8990  *    Function : freeInitUlRrcMsgTransfer
8991  *
8992  *    Functionality: Free memory allocated in InitialULRRCMessage
8993  *
8994  * @params[in]F1AP_PDU_t  *f1apMsg)
8995  *
8996  * @return ROK     - success
8997  *         RFAILED - failure
8998  *
8999  * ****************************************************************/
9000
9001 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
9002 {
9003    uint8_t ieIdx, arrIdx;
9004    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
9005
9006    if(f1apMsg)
9007    {
9008       if(f1apMsg->choice.initiatingMessage)
9009       {
9010          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
9011             choice.InitialULRRCMessageTransfer;
9012          if(initULRRCMsg->protocolIEs.list.array)
9013          {
9014             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
9015             {
9016                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
9017                {
9018                   case ProtocolIE_ID_id_NRCGI:
9019                   {
9020                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
9021                      {
9022                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
9023                         {
9024                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
9025                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
9026                         }
9027                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
9028                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
9029                      }
9030                      break;
9031                   }
9032                   case ProtocolIE_ID_id_RRCContainer:
9033                   {
9034                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
9035                      {
9036                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
9037                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
9038                      }
9039                      break;
9040                   }
9041                   case ProtocolIE_ID_id_DUtoCURRCContainer:
9042                   {
9043                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
9044                      {
9045                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
9046                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
9047                      }
9048                      break;
9049                   }
9050                   default:
9051                      break;
9052                }
9053              }
9054              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9055              {
9056                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
9057                 {
9058                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
9059                       sizeof(InitialULRRCMessageTransferIEs_t));
9060                 }
9061              }
9062              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
9063           }
9064          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
9065       }
9066       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9067    }
9068    else
9069    {
9070       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
9071       return RFAILED;
9072    }
9073    return ROK;
9074 }
9075
9076 /*******************************************************************
9077  *
9078  * @brief Builds and sends the InitialULRRCMessage
9079  *
9080  * @details
9081  *
9082  *    Function : BuildAndSendInitialRrcMsgTransfer
9083  *
9084  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
9085  *                   it to the CU through SCTP.
9086  *
9087  * @params[in]
9088  *
9089  * @return ROK     - success
9090  *         RFAILED - failure
9091  *
9092  * ****************************************************************/
9093 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
9094       uint16_t rrcContSize, uint8_t *rrcContainer)
9095 {
9096    uint8_t   ret;
9097    uint8_t   elementCnt;
9098    uint8_t   ieIdx, cellIdx, ueIdx;
9099    DuUeCb    *duUeCb = NULLP;
9100    asn_enc_rval_t  encRetVal;
9101    F1AP_PDU_t  *f1apMsg = NULLP;
9102    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
9103    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
9104
9105    while(true)
9106    {
9107       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
9108       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9109       if(f1apMsg == NULLP)
9110       {
9111          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9112          break;
9113       }
9114       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
9115       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
9116       if(f1apMsg->choice.initiatingMessage == NULLP)
9117       {
9118          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
9119          break;
9120       }
9121       f1apMsg->choice.initiatingMessage->procedureCode =\
9122                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
9123       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
9124       f1apMsg->choice.initiatingMessage->value.present = \
9125                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
9126       initULRRCMsg =\
9127                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
9128       elementCnt = 5;
9129       initULRRCMsg->protocolIEs.list.count = elementCnt;
9130       initULRRCMsg->protocolIEs.list.size = \
9131                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
9132       /* Initialize the F1Setup members */
9133       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
9134       if(initULRRCMsg->protocolIEs.list.array == NULLP)
9135       {
9136          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
9137                RRCSetupRequestMessageTransferIEs failed");
9138          break;
9139       }
9140       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
9141       {
9142          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
9143                sizeof(InitialULRRCMessageTransferIEs_t));
9144          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
9145          {
9146             break;
9147          }
9148       }
9149       ieIdx = 0;
9150       /*GNB DU UE F1AP ID*/
9151       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
9152                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
9153       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
9154       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
9155                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
9156       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
9157
9158
9159       /*NRCGI*/
9160       ieIdx++;
9161       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
9162                                                         ProtocolIE_ID_id_NRCGI;
9163       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
9164       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
9165                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
9166
9167       ret =\
9168            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
9169       if(ret!=ROK)
9170       {
9171          break;
9172       }
9173
9174       /*CRNTI*/
9175       ieIdx++;
9176       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
9177                                                         ProtocolIE_ID_id_C_RNTI;
9178       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
9179       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
9180                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
9181       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
9182
9183       /*RRCContainer*/
9184       ieIdx++;
9185       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
9186                                                         ProtocolIE_ID_id_RRCContainer;
9187       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
9188       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
9189                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
9190
9191       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
9192       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
9193             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
9194       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
9195       {
9196          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
9197          break;
9198
9199       }
9200       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
9201             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
9202
9203
9204       /*DUtoCURRCContainer*/
9205       ieIdx++;
9206       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
9207       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
9208       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
9209                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
9210
9211       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
9212       {
9213          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9214          {
9215             if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
9216                   (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti == crnti))
9217             {
9218                duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
9219             }
9220          }
9221       }
9222
9223       ret = BuildCellGroupConfigRrc(duUeCb, &initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
9224       if(ret != ROK)
9225       {
9226          break;
9227       }
9228
9229       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9230
9231       /* Encode the Intial UL RRC Message transfer as APER */
9232       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9233       encBufSize = 0;
9234       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9235       /* Encode results */
9236       if(encRetVal.encoded == ENCODE_FAIL)
9237       {
9238          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
9239                structure (at %s)\n",encRetVal.failed_type ? \
9240                encRetVal.failed_type->name : "unknown");
9241          ret = RFAILED;
9242          break;
9243       }
9244       else
9245       {
9246
9247          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
9248                Message transfer\n");
9249 #ifdef DEBUG_ASN_PRINT
9250          for(int i=0; i< encBufSize; i++)
9251          {
9252             printf("%x",encBuf[i]);
9253          }
9254 #endif
9255       }
9256       /* Sending  msg  */
9257       if(sendF1APMsg() != ROK)
9258       {
9259          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
9260          ret = RFAILED;
9261          break;
9262       }
9263       break;
9264    }
9265    freeInitUlRrcMsgTransfer(f1apMsg);
9266    return ret;
9267 }/* End of BuildAndSendInitialRrcMsgTransfer*/
9268
9269 /*****  UE SETUP REQUEST *****/
9270
9271 /******************************************************************
9272 *
9273 * @brief Function to delete the RLC Lc cfg from UE APP DB
9274 *
9275 * @details
9276 *
9277 *  Function : freeRlcLcCfg
9278 *
9279 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
9280 *
9281 *
9282  *****************************************************************/
9283
9284 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
9285 {
9286    switch(lcCfg->rlcMode)
9287    {
9288       case RLC_AM :
9289          {
9290             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
9291             break;
9292          }
9293       case RLC_UM_BI_DIRECTIONAL :
9294          {
9295             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
9296             break;
9297          }
9298       case RLC_UM_UNI_DIRECTIONAL_UL :
9299          {
9300             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
9301             break;
9302          }
9303       case RLC_UM_UNI_DIRECTIONAL_DL :
9304          {
9305             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
9306             break;
9307          }
9308       default:
9309          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
9310          break;
9311    }
9312    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
9313 }
9314
9315 /*******************************************************************
9316  *
9317  * @brief Function to free MacLcCfg
9318  *
9319  * @details
9320  *
9321  *    Function : freeMacLcCfg
9322  *
9323  *    Functionality: Function to free MacLcCfg
9324  *
9325  * @params[in] LcCfg *lcCfg,
9326  * @return void
9327  *
9328  * ****************************************************************/
9329
9330 void freeMacLcCfg(LcCfg *lcCfg)
9331 {
9332     /* Deleting DRBQOS */
9333    if(lcCfg->drbQos)
9334    {
9335       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
9336    }
9337    /* Deleting SNSSAI */
9338    if(lcCfg->snssai)
9339    {
9340       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
9341    }
9342 }
9343 /*******************************************************************
9344  *
9345  * @brief Free UE NR Capability received in UE Context setup request
9346  *
9347  * @details
9348  *
9349  *    Function : freeAperDecodeUeNrCapability
9350  *
9351  *    Functionality:
9352  *       Free UE NR Capability received in UE Context setup request
9353  *
9354  * @params[in]
9355  * @return ROK     - success
9356  *         RFAILED - failure
9357  *
9358  * ****************************************************************/
9359 void freeAperDecodeUeNrCapability(void *ueNrCapability)
9360 {
9361    uint8_t arrIdx =0;
9362    FeatureSets_t *featureSets =NULLP;
9363    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
9364
9365    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
9366    {
9367       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
9368       {
9369          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
9370             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
9371       }
9372       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
9373    }
9374
9375    if(ueNrCap->featureSets)
9376    {
9377       featureSets = ueNrCap->featureSets;
9378       if(featureSets->featureSetsDownlinkPerCC)
9379       {
9380          if(featureSets->featureSetsDownlinkPerCC->list.array)
9381          {
9382             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
9383             {
9384                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
9385                {
9386                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
9387                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
9388                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
9389                }
9390             }
9391             free(featureSets->featureSetsDownlinkPerCC->list.array);
9392          }
9393          free(featureSets->featureSetsDownlinkPerCC);
9394       }
9395       if(featureSets->featureSetsUplinkPerCC)
9396       {
9397          if(featureSets->featureSetsUplinkPerCC->list.array)
9398          {
9399             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
9400             {
9401                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
9402                {
9403                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
9404                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
9405                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
9406                }
9407             }
9408             free(featureSets->featureSetsUplinkPerCC->list.array);
9409          }
9410          free(featureSets->featureSetsUplinkPerCC);
9411       }
9412       free(ueNrCap->featureSets);
9413    }
9414 }
9415
9416 /*******************************************************************
9417 *
9418 * @brief Function to free PdcchSearchSpcToAddModList
9419          where memory allocated by aper_decoder
9420 *
9421 * @details
9422 *
9423 *    Function : freeAperDecodePdcchSearchSpcToAddModList
9424 *
9425 *    Functionality: Function to free PdcchSearchSpcToAddModList
9426 *
9427 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
9428 * @return void
9429 *
9430 * ****************************************************************/
9431
9432 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
9433 {
9434    uint8_t searchSpcArrIdx=0;
9435    uint8_t searchSpcArrIdx1=0;
9436    struct  SearchSpace *searchSpc=NULLP;
9437
9438
9439    if(searchSpcList->list.array)
9440    {
9441       if(searchSpcList->list.array[searchSpcArrIdx1])
9442       {
9443          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
9444          if(searchSpc->controlResourceSetId)
9445          {
9446             if(searchSpc->monitoringSlotPeriodicityAndOffset)
9447             {
9448                if(searchSpc->monitoringSymbolsWithinSlot)
9449                {
9450                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
9451                   {
9452                      if(searchSpc->nrofCandidates)
9453                      {
9454                         if(searchSpc->searchSpaceType)
9455                         {
9456                            free(searchSpc->searchSpaceType->choice.ue_Specific);
9457                            free(searchSpc->searchSpaceType);
9458                         }
9459                         free(searchSpc->nrofCandidates);
9460                      }
9461                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
9462                   }
9463                   free(searchSpc->monitoringSymbolsWithinSlot);
9464                }
9465                free(searchSpc->monitoringSlotPeriodicityAndOffset);
9466             }
9467             free(searchSpc->controlResourceSetId);
9468          }
9469       }
9470       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
9471       {
9472          free(searchSpcList->list.array[searchSpcArrIdx]);
9473       }
9474       free(searchSpcList->list.array);
9475    }
9476 }
9477 /*******************************************************************
9478 *
9479 * @brief Function for free part for the memory allocated by aper_decoder
9480 *
9481 * @details
9482 *
9483 *    Function : freeAperDecodeBWPDlDedPdcchConfig
9484 *
9485 *    Functionality: Function to free BWPDlDedPdcchConfig
9486 *
9487 * @params[in]
9488 * @return void
9489 *
9490 * ****************************************************************/
9491
9492
9493 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
9494 {
9495    uint8_t arrIdx1=0;
9496    uint8_t arrIdx2=0;
9497    struct PDCCH_Config *pdcchCfg=NULLP;
9498    struct ControlResourceSet *controlRSet=NULLP;
9499    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
9500
9501    if(dlBwp->pdcch_Config->choice.setup)
9502    {
9503       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
9504       if(pdcchCfg->controlResourceSetToAddModList)
9505       {
9506          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
9507          if(controlRSetList->list.array)
9508          {
9509             controlRSet = controlRSetList->list.array[arrIdx2];
9510             if(controlRSet)
9511             {
9512                if(controlRSet->frequencyDomainResources.buf)
9513                {
9514                   if(controlRSet->pdcch_DMRS_ScramblingID)
9515                   {
9516                      if(pdcchCfg->searchSpacesToAddModList)
9517                      {
9518                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
9519                         free(pdcchCfg->searchSpacesToAddModList);
9520                      }
9521                      free(controlRSet->pdcch_DMRS_ScramblingID);
9522                   }
9523                   free(controlRSet->frequencyDomainResources.buf);
9524                }
9525             }
9526             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
9527             {
9528                free(controlRSetList->list.array[arrIdx1]);
9529             }
9530             free(controlRSetList->list.array);
9531          }
9532          free(pdcchCfg->controlResourceSetToAddModList);
9533       }
9534       free(dlBwp->pdcch_Config->choice.setup);
9535    }
9536 }
9537 /*******************************************************************
9538 *
9539 * @brief Function to free PdschTimeDomAllocationList
9540 *     where the memory allocated by aper_decoder
9541 *
9542 * @details
9543 *
9544 *    Function : freeAperDecodePdschTimeDomAllocationList
9545 *
9546 *    Functionality: Function to free PdschTimeDomAllocationList
9547 *
9548 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
9549 * @return void
9550 *
9551 * ****************************************************************/
9552
9553
9554 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
9555 {
9556    uint8_t arrIdx=0;
9557
9558    if(timeDomAllocList->choice.setup)
9559    {
9560       if(timeDomAllocList->choice.setup->list.array)
9561       {
9562          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
9563          {
9564             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
9565          }
9566          free(timeDomAllocList->choice.setup->list.array);
9567       }
9568       free(timeDomAllocList->choice.setup);
9569    }
9570 }
9571
9572 /*******************************************************************
9573 *
9574 * @brief Function to free BWPDlDedPdschConfig
9575 *        where the memory allocated by aper_decoder
9576 *
9577 * @details
9578 *
9579 *    Function : freeAperDecodeBWPDlDedPdschConfig
9580 *
9581 *    Functionality: Function to free BWPDlDedPdschConfig
9582 *
9583 * @params[in] BWP_DownlinkDedicated_t *dlBwp
9584 * @return void
9585 *
9586 * ****************************************************************/
9587
9588
9589 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
9590 {
9591    struct PDSCH_Config *pdschCfg=NULLP;
9592    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
9593    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
9594    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
9595
9596    if(dlBwp->pdsch_Config->choice.setup)
9597    {
9598       pdschCfg=dlBwp->pdsch_Config->choice.setup;
9599       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
9600       {
9601          if(pdschCfg->pdsch_TimeDomainAllocationList)
9602          {
9603             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
9604             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
9605             {
9606                prbBndlType=&pdschCfg->prb_BundlingType;
9607                free(prbBndlType->choice.staticBundling);
9608                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
9609             }
9610             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
9611             free(pdschCfg->pdsch_TimeDomainAllocationList);
9612          }
9613          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
9614          if(dmrsDlCfg->choice.setup)
9615          {
9616             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
9617             free(dmrsDlCfg->choice.setup);
9618          }
9619          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
9620       }
9621       free(dlBwp->pdsch_Config->choice.setup);
9622    }
9623 }
9624 /*******************************************************************
9625 *
9626 * @brief Function to free PuschTimeDomAllocListCfg
9627                  where the memory allocated by aper_decoder
9628 *
9629 * @details
9630 *
9631 *    Function : freeAperDecodePuschTimeDomAllocListCfg
9632 *
9633 *    Functionality: Function to free PuschTimeDomAllocListCfg
9634 *
9635 * @params[in] PUSCH_Config_t *puschCfg
9636 * @return void
9637 *
9638 * ****************************************************************/
9639
9640
9641 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
9642 {
9643    uint8_t arrIdx=0;
9644    uint8_t arrIdx1=0;
9645    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
9646
9647    if(puschCfg->pusch_TimeDomainAllocationList)
9648    {
9649       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
9650       if(timeDomAllocList_t->choice.setup)
9651       {
9652          if(timeDomAllocList_t->choice.setup->list.array)
9653          {
9654             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
9655             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
9656             {
9657                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
9658             }
9659             free(timeDomAllocList_t->choice.setup->list.array);
9660          }
9661          free(timeDomAllocList_t->choice.setup);
9662       }
9663       free(puschCfg->transformPrecoder);
9664       free(puschCfg->pusch_TimeDomainAllocationList);
9665    }
9666 }
9667 /*******************************************************************
9668 *
9669 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
9670 *
9671 * @details
9672 *
9673 *    Function : freeAperDecodeInitialUlBWPConfig
9674 *
9675 *    Functionality: Function to free InitialUlBWPConfig
9676 *
9677 * @params[in]  BWP_UplinkDedicated_t *ulBwp
9678 * @return void
9679 *
9680 * ****************************************************************/
9681
9682
9683 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
9684 {
9685    uint8_t  rSetIdx =0;
9686    uint8_t  rsrcIdx =0;
9687    SRS_Config_t   *srsCfg = NULLP;
9688    PUSCH_Config_t *puschCfg = NULLP;
9689    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
9690    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
9691    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
9692    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
9693
9694    if(ulBwp->pusch_Config)
9695    {
9696       if(ulBwp->pusch_Config->choice.setup)
9697       {
9698          puschCfg=ulBwp->pusch_Config->choice.setup;
9699          if(puschCfg->dataScramblingIdentityPUSCH)
9700          {
9701             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
9702             {
9703                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
9704                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
9705                if(dmrsUlCfg->choice.setup)
9706                {
9707                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
9708                   {
9709                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
9710                      {
9711                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
9712                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
9713                      }
9714                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
9715                   }
9716                   free(dmrsUlCfg->choice.setup);
9717                }
9718                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
9719             }
9720             free(puschCfg->dataScramblingIdentityPUSCH);
9721          }
9722          free(ulBwp->pusch_Config->choice.setup);
9723       }
9724       free(ulBwp->pusch_Config);
9725
9726       /* Free SRS-Config */
9727       if(ulBwp->srs_Config)
9728       {
9729          if(ulBwp->srs_Config->choice.setup)
9730          {
9731             srsCfg = ulBwp->srs_Config->choice.setup;
9732
9733             /* Free Resource Set to add/mod list */
9734             if(srsCfg->srs_ResourceSetToAddModList)
9735             {
9736                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
9737                if(rsrcSetList->list.array)
9738                {
9739                   rSetIdx = 0;
9740
9741                   /* Free SRS resource Id list in this SRS resource set */
9742                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
9743                   {
9744                      rsrcIdList =
9745                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
9746
9747                      if(rsrcIdList->list.array)
9748                      {
9749                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
9750                               rsrcIdx++)
9751                         {
9752                            free(rsrcIdList->list.array[rsrcIdx]);
9753                         }
9754                         free(rsrcIdList->list.array);
9755                      }
9756                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
9757                   }
9758
9759                   /* Free resource type info for this SRS resource set */
9760
9761                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
9762
9763                   /* Free memory for each resource set */
9764                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
9765                   {
9766                      free(rsrcSetList->list.array[rSetIdx]);
9767                   }
9768                   free(rsrcSetList->list.array);
9769                }
9770                free(srsCfg->srs_ResourceSetToAddModList);
9771             }
9772
9773             /* Free resource to add/modd list */
9774             if(srsCfg->srs_ResourceToAddModList)
9775             {
9776                resourceList = srsCfg->srs_ResourceToAddModList;
9777                if(resourceList->list.array)
9778                {
9779                   rsrcIdx = 0;
9780
9781                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
9782                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
9783
9784                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
9785                   {
9786                      free(resourceList->list.array[rsrcIdx]);
9787                   }
9788                   free(resourceList->list.array);
9789                }
9790                free(srsCfg->srs_ResourceToAddModList);
9791             }
9792
9793             free(ulBwp->srs_Config->choice.setup);
9794          }
9795          free(ulBwp->srs_Config);
9796       }
9797    }
9798 }
9799 /*******************************************************************
9800 *
9801 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
9802 *
9803 * @details
9804 *
9805 *    Function : freeAperDecodeinitialUplinkBWPConfig
9806 *
9807 *    Functionality: Function to free initialUplinkBWPConfig
9808 *
9809 * @params[in] UplinkConfig_t *ulCfg
9810 * @return void
9811 *
9812 * ****************************************************************/
9813
9814
9815 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
9816 {
9817    BWP_UplinkDedicated_t *ulBwp=NULLP;
9818    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
9819
9820    if(ulCfg->initialUplinkBWP)
9821    {
9822       ulBwp=ulCfg->initialUplinkBWP;
9823       if(ulCfg->firstActiveUplinkBWP_Id)
9824       {
9825          if(ulCfg->pusch_ServingCellConfig)
9826          {
9827             puschCfg=ulCfg->pusch_ServingCellConfig;
9828             if(puschCfg->choice.setup)
9829             {
9830                if(puschCfg->choice.setup->ext1)
9831                {
9832                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
9833                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
9834                   free(puschCfg->choice.setup->ext1);
9835                }
9836                free(puschCfg->choice.setup);
9837             }
9838             free(ulCfg->pusch_ServingCellConfig);
9839          }
9840          free(ulCfg->firstActiveUplinkBWP_Id);
9841       }
9842       freeAperDecodeInitialUlBWPConfig(ulBwp);
9843       free(ulCfg->initialUplinkBWP);
9844    }
9845 }
9846
9847 /*******************************************************************
9848  *
9849  * @brief Function to free DuUeCfg
9850  *
9851  * @details
9852  *
9853  *    Function : freeDuUeCfg
9854  *
9855  *    Functionality: Function to free DuUeCfg
9856  *
9857  * @params[in] DuUeCfg *ueCfg
9858  * @return void
9859  *
9860  * ****************************************************************/
9861 void freeDuUeCfg(UeCtxtActionType actionType, DuUeCfg *ueCfg)
9862 {
9863    uint8_t lcIdx = 0;
9864    uint8_t arrIdx = 0;
9865    SpCellConfig_t *spCellCfg = NULLP;
9866    ServingCellConfig_t *srvCellCfg = NULLP;
9867    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9868    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
9869    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9870    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
9871    struct RLC_Config *rlcConfig = NULLP;
9872    struct LogicalChannelConfig *macLcConfig = NULLP;
9873    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
9874    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
9875    struct TAG_Config *tagConfig = NULLP;
9876    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
9877    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
9878    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
9879    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
9880
9881    if(ueCfg->ueNrCapability)
9882    {
9883       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
9884       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
9885       ueCfg->ueNrCapability = NULLP;
9886    }
9887
9888    if(ueCfg->cellGrpCfg)
9889    {
9890       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
9891       if(rlcBearerList)
9892       {
9893          if(rlcBearerList->list.array)
9894          {
9895             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
9896             {
9897                if(rlcBearerList->list.array[arrIdx])
9898                {
9899                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
9900                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
9901
9902                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
9903                   {
9904                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
9905                   }
9906                   if(rlcConfig)
9907                   {
9908                      if(rlcConfig->choice.am)
9909                      {
9910                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
9911                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
9912                         free(rlcConfig->choice.am);
9913                      }
9914                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
9915                   }
9916                   if(macLcConfig)
9917                   {
9918                      if(macLcConfig->ul_SpecificParameters)
9919                      {
9920                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
9921                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
9922                         free(macLcConfig->ul_SpecificParameters);
9923                      }
9924                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
9925                   }
9926                   free(rlcBearerList->list.array[arrIdx]);
9927                }
9928             }
9929             free(rlcBearerList->list.array);
9930          }
9931          free(cellGrpCfg->rlc_BearerToAddModList);
9932       }
9933
9934       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
9935       if(macCellGrpCfg)
9936       {
9937          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
9938          if(schedulingRequestConfig)
9939          {
9940             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
9941             if(schReqList)
9942             {
9943                if(schReqList->list.array)
9944                {
9945                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
9946                   {
9947                      if(schReqList->list.array[arrIdx])
9948                      {
9949                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
9950                         free(schReqList->list.array[arrIdx]);
9951                      }
9952                   }
9953                   free(schReqList->list.array);
9954                }
9955                free(schedulingRequestConfig->schedulingRequestToAddModList);
9956             }
9957             free(macCellGrpCfg->schedulingRequestConfig);
9958          }
9959          if(macCellGrpCfg->bsr_Config)
9960          {
9961             free(macCellGrpCfg->bsr_Config);
9962          }
9963          tagConfig = macCellGrpCfg->tag_Config;
9964          if(tagConfig)
9965          {
9966             tagList = tagConfig->tag_ToAddModList;
9967             if(tagList)
9968             {
9969                if(tagList->list.array)
9970                {
9971                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
9972                   {
9973                      free(tagList->list.array[arrIdx]);
9974                   }
9975                   free(tagList->list.array);
9976                }
9977                free(tagConfig->tag_ToAddModList);
9978             }
9979             free(tagConfig);
9980          }
9981
9982          phrConfig = macCellGrpCfg->phr_Config;
9983          if(phrConfig)
9984          {
9985             free(phrConfig->choice.setup);
9986             free(phrConfig);
9987          }
9988
9989          free(macCellGrpCfg);
9990       }
9991
9992       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
9993       if(phyCellGrpCfg)
9994       {
9995          free(phyCellGrpCfg->p_NR_FR1);
9996          free(phyCellGrpCfg);
9997       }
9998
9999       spCellCfg = cellGrpCfg->spCellConfig;
10000       if(spCellCfg)
10001       {
10002          if(spCellCfg->servCellIndex)
10003          {
10004             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
10005             {
10006                if(spCellCfg->spCellConfigDedicated)
10007                {
10008                   srvCellCfg = spCellCfg->spCellConfigDedicated;
10009                   if(srvCellCfg->initialDownlinkBWP)
10010                   {
10011                      dlBwp = srvCellCfg->initialDownlinkBWP;
10012                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
10013                      {
10014                         if(srvCellCfg->defaultDownlinkBWP_Id)
10015                         {
10016                            if(srvCellCfg->uplinkConfig)
10017                            {
10018
10019                               if(srvCellCfg->pdsch_ServingCellConfig)
10020                               {
10021                                  pdschCfg=
10022                                     srvCellCfg->pdsch_ServingCellConfig;
10023                                  if(pdschCfg->choice.setup)
10024                                  {
10025
10026                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
10027                                     free(pdschCfg->choice.setup);
10028                                  }
10029
10030                                  free(srvCellCfg->pdsch_ServingCellConfig);
10031                               }
10032
10033                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
10034                               free(srvCellCfg->uplinkConfig);
10035                            }
10036                            free(srvCellCfg->defaultDownlinkBWP_Id);
10037                         }
10038
10039                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
10040                      }
10041                      if(dlBwp->pdcch_Config)
10042                      {
10043                         if(dlBwp->pdsch_Config)
10044                         {
10045                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
10046                            free(dlBwp->pdsch_Config);
10047                         }
10048                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
10049                         free(dlBwp->pdcch_Config);
10050                      }
10051                      free(srvCellCfg->initialDownlinkBWP);
10052                   }
10053
10054                   free(spCellCfg->spCellConfigDedicated);
10055                }
10056                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
10057             }
10058             free(spCellCfg->servCellIndex);
10059          }
10060          free(spCellCfg);
10061       }
10062       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
10063       ueCfg->cellGrpCfg = NULLP;
10064    }
10065
10066    if(ueCfg->ambrCfg)
10067    {
10068       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
10069    }
10070
10071    if(actionType != UE_CTXT_CFG_QUERY)
10072    {
10073       for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
10074       {
10075          freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx].rlcBearerCfg);
10076       }
10077    }
10078
10079    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
10080    {
10081       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx].lcConfig);
10082    }
10083
10084    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
10085    {
10086       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
10087    }
10088 }
10089
10090 /*******************************************************************
10091  *
10092  * @brief Function to free UecontextSetupDb
10093  *
10094  * @details
10095  *
10096  *    Function : freeF1UeDb
10097  *
10098  *    Functionality: Function to free UecontextSetupDb
10099  *
10100  * @params[in] UecontextSetupDb *
10101  * @return void
10102  *
10103  * ****************************************************************/
10104
10105 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
10106 {
10107
10108    if(f1UeDb->dlRrcMsg)
10109    {
10110       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
10111       {
10112         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
10113                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
10114       }
10115       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10116    }
10117    freeDuUeCfg(f1UeDb->actionType, &f1UeDb->duUeCfg);
10118    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
10119    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
10120 }
10121
10122 /*******************************************************************
10123  *
10124  * @brief Function to build Am cfg Info
10125  *
10126  * @details
10127  *
10128  *    Function : extractRlcAmCfg
10129  *
10130  *    Functionality: Function to build Am cfg Info
10131  *
10132  * @params[in] AmBearerCfg *
10133  *             void *
10134  *
10135  * @return ROK/RFAILED
10136  *
10137  * ****************************************************************/
10138
10139 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
10140 {
10141    if(rlcAmCfg)
10142    {
10143       /* UL AM */
10144       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
10145       {
10146          amCfgToSet->ulAmCfg.snLenUl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->dl_AM_RLC.sn_FieldLength));
10147          /*TODO: Check the timer value when sent by real CU */
10148          amCfgToSet->ulAmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_Reassembly);
10149          amCfgToSet->ulAmCfg.statProhTmr = convertProhibitTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_StatusProhibit);
10150       }
10151
10152       /* DL AM */
10153       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
10154       {
10155          amCfgToSet->dlAmCfg.snLenDl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->ul_AM_RLC.sn_FieldLength));
10156          amCfgToSet->dlAmCfg.pollRetxTmr = covertPollRetxTmrEnumToValue(rlcAmCfg->ul_AM_RLC.t_PollRetransmit);
10157          amCfgToSet->dlAmCfg.pollPdu   = covertPollPduEnumToValue(rlcAmCfg->ul_AM_RLC.pollPDU);
10158          amCfgToSet->dlAmCfg.pollByte  = covertPollByteEnumToValue(rlcAmCfg->ul_AM_RLC.pollByte);
10159          amCfgToSet->dlAmCfg.maxRetxTh = covertMaxRetxEnumToValue(rlcAmCfg->ul_AM_RLC.maxRetxThreshold);
10160       }
10161    }
10162 }
10163
10164 /*******************************************************************
10165  *
10166  * @brief Function to build Um Bi Info
10167  *
10168  * @details
10169  *
10170  *    Function : extractRlcUmBiCfg
10171  *
10172  *    Functionality: Function to build Um Bi Info
10173  *
10174  * @params[in] UmBiDirBearerCfg *
10175  *             void *
10176  *
10177  * @return ROK/RFAILED
10178  *
10179  * ****************************************************************/
10180
10181 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
10182 {
10183    if(rlcBiCfg)
10184    {
10185       /* UL UM BI DIR Cfg */
10186       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
10187       {
10188          umBiCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->dl_UM_RLC.sn_FieldLength));
10189          umBiCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcBiCfg->dl_UM_RLC.t_Reassembly);
10190       }
10191
10192       /* DL UM BI DIR Cfg */
10193       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
10194          umBiCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->ul_UM_RLC.sn_FieldLength));
10195    }
10196 }
10197
10198 /*******************************************************************
10199  *
10200  * @brief Function to build Um Ul Info
10201  *
10202  * @details
10203  *
10204  *    Function : extractRlcUmUlCfg
10205  *
10206  *    Functionality: Function to build Um Ul Info
10207  *
10208  * @params[in] UmUniDirUlBearerCfg *
10209  *             void *
10210  *
10211  * @return ROK/RFAILED
10212  *
10213  * ****************************************************************/
10214
10215 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
10216 {
10217    if(umUlCfg)
10218    {
10219       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
10220       {
10221          umUlCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umUlCfg->dl_UM_RLC.sn_FieldLength));
10222          umUlCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(umUlCfg->dl_UM_RLC.t_Reassembly);
10223       }
10224    }
10225 }
10226
10227 /*******************************************************************
10228  *
10229  * @brief Function to build Um Uni Dl Info
10230  *
10231  * @details
10232  *
10233  *    Function : extractRlcUmDlCfg
10234  *
10235  *    Functionality: Function to build Um Uni Dl Info
10236  *
10237  * @params[in] UmUniDirDlBearerCfg *
10238  *             void *
10239  *
10240  * @return ROK/RFAILED
10241  *
10242  * ****************************************************************/
10243 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
10244 {
10245    if(umDlCfg)
10246    {
10247       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
10248          umDlCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umDlCfg->ul_UM_RLC.sn_FieldLength));
10249    }
10250 }
10251
10252 /*******************************************************************
10253  *
10254  * @brief Function to extractRlcModeCfg
10255  *
10256  * @details
10257  *
10258  *    Function : extractRlcModeCfg
10259  *
10260  *    Functionality: Function to extractRlcModeCfg
10261  *
10262  * @params[in] RLC_Config_t *
10263  *             RlcBearerCfg *
10264  *             void  *
10265  * @return ROK/RFAILED
10266  *
10267  * ****************************************************************/
10268 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
10269 {
10270    if(lcCfg)
10271    {
10272       switch(rlcMode)
10273       {
10274          case RLC_AM :
10275             {
10276                if(lcCfg->choice.am)
10277                {
10278                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
10279                   if(rlcDbCfg->u.amCfg)
10280                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
10281                }
10282                break;
10283             }
10284          case RLC_UM_BI_DIRECTIONAL :
10285             {
10286                if(lcCfg->choice.um_Bi_Directional)
10287                {
10288                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
10289                   if(rlcDbCfg->u.umBiDirCfg)
10290                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
10291                }
10292                break;
10293             }
10294          case RLC_UM_UNI_DIRECTIONAL_UL :
10295             {
10296                if(lcCfg->choice.um_Uni_Directional_DL)
10297                {
10298                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
10299                   if(rlcDbCfg->u.umUniDirUlCfg)
10300                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
10301                }
10302                break;
10303             }
10304          case RLC_UM_UNI_DIRECTIONAL_DL :
10305             {
10306                if(lcCfg->choice.um_Uni_Directional_UL)
10307                {
10308                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
10309                   if(rlcDbCfg->u.umUniDirDlCfg)
10310                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
10311                }
10312                break;
10313             }
10314          default:
10315             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
10316             break;
10317       }
10318    }
10319 }
10320
10321 /*******************************************************************
10322  *
10323  * @brief Function to extract extractUlLcCfg
10324  *
10325  * @details
10326  *
10327  *    Function : extractUlLcCfg
10328  *
10329  *    Functionality: Function to extract extractUlLcCfg
10330  *
10331  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
10332  * @return void
10333  *
10334  * ****************************************************************/
10335
10336 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
10337 {
10338    if(ulLcCfg)
10339    {
10340       if(ulLcCfg->ul_SpecificParameters)
10341       {
10342          f1UlLcCfg->priority = \
10343             ulLcCfg->ul_SpecificParameters->priority;
10344       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
10345       {
10346          f1UlLcCfg->lcGroup = \
10347            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
10348       }
10349       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
10350       {
10351          f1UlLcCfg->schReqId = \
10352            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
10353       }
10354       f1UlLcCfg->pbr = \
10355          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
10356       f1UlLcCfg->bsd = \
10357          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
10358       }
10359    }
10360 }
10361
10362 /*******************************************************************
10363 *
10364 * @brief Function to extract Snssai Cfg Info from CU
10365 *
10366 * @details
10367 *
10368 *    Function : extractDrbSnssaiCfg
10369 *
10370 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
10371 *
10372 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
10373 * @return ROK/RFAILED
10374 *
10375 * ****************************************************************/
10376
10377 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
10378 {
10379    if(!(*snssaiToBeShared))
10380    {
10381       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
10382       if(snssaiToBeShared == NULLP)
10383       {
10384          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
10385          return RFAILED;
10386       }
10387    }
10388    if(RecvSnssai)
10389    {
10390       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
10391       if(RecvSnssai->sD)
10392       {
10393          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
10394       }
10395       else
10396       {
10397          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
10398          return RFAILED;
10399       }
10400    }
10401    return ROK;
10402 }
10403
10404 /*******************************************************************
10405  *
10406  * @brief Function to procRlcLcCfg
10407  *
10408  * @details
10409  *
10410  *    Function : procRlcLcCfg
10411  *
10412  *    Functionality: Function to procRlcLcCfg
10413  *
10414  * @params[in] rbId, lcId, rbType, rlcMod
10415  *             RLC_Config_t *, RlcBearerCfg * ,
10416  * @return void
10417  *
10418  * ****************************************************************/
10419
10420 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
10421    uint8_t configType, RLC_Config_t *f1RlcCfg, DuRlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
10422 {
10423    DRB_Information_t *drbInfo;
10424
10425    lcCfg->rlcBearerCfg.rbId   = rbId;
10426    lcCfg->configType = configType;
10427
10428    if(rbType == RB_TYPE_SRB)
10429    {
10430       lcCfg->rlcBearerCfg.rbType = RB_TYPE_SRB;
10431       lcCfg->rlcBearerCfg.lcId   = rbId;
10432       lcCfg->rlcBearerCfg.lcType = LCH_DCCH;
10433       lcCfg->rlcBearerCfg.rlcMode = RLC_AM;
10434    }
10435    else if(rbType == RB_TYPE_DRB)
10436    {
10437       lcCfg->rlcBearerCfg.rbType = RB_TYPE_DRB;
10438       lcCfg->rlcBearerCfg.lcId   = lcId;
10439       lcCfg->rlcBearerCfg.lcType = LCH_DTCH;
10440       lcCfg->rlcBearerCfg.rlcMode = rlcMode;
10441    }
10442    if(f1RlcCfg) /* rlc mode config recived */
10443    {
10444       extractRlcModeCfg(lcCfg->rlcBearerCfg.rlcMode, &lcCfg->rlcBearerCfg, f1RlcCfg);
10445    }
10446    if(qoSInformation != NULLP)
10447    {
10448       if(qoSInformation->present == QoSInformation_PR_choice_extension)
10449       {
10450          if(qoSInformation->choice.choice_extension->value.present ==\
10451                QoSInformation_ExtIEs__value_PR_DRB_Information)
10452          {
10453             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10454             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->rlcBearerCfg.snssai) != ROK)
10455             {
10456                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
10457                return;
10458             }
10459          }
10460       }
10461    }
10462 }
10463
10464 /*******************************************************************
10465  *
10466  * @brief Fills DrbQos Info received by CU
10467  *
10468  * @details
10469  *
10470  *    Function : extractQosInfo
10471  *
10472  *    Functionality: Fills DrbQos Info received  by CU
10473  *
10474  * @params[in] DrbQosInfo *qosToAdd,
10475  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
10476  * @return void
10477  *
10478  * ****************************************************************/
10479
10480 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
10481 {
10482    uint8_t qosCntIdx = 0;
10483    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
10484
10485    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
10486    qosToAdd->u.nonDyn5Qi.fiveQi     =\
10487                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
10488    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
10489    {
10490       qosToAdd->u.nonDyn5Qi.avgWindow = \
10491                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
10492    }
10493
10494    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume)
10495    {
10496       qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
10497                                               *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
10498    }
10499
10500    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
10501    {
10502       qosToAdd->u.nonDyn5Qi.priorLevel = \
10503                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
10504    }
10505    qosToAdd->ngRanRetPri.priorityLevel = \
10506                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
10507    qosToAdd->ngRanRetPri.preEmptionCap = \
10508                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
10509    qosToAdd->ngRanRetPri.preEmptionVul = \
10510                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
10511    if(qosFlowCfg->gBR_QoS_Flow_Information)
10512    {
10513       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
10514             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
10515             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
10516       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
10517             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
10518             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
10519       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
10520             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
10521             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
10522       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
10523             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
10524             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
10525    }
10526    /*Extracting PDU_SESSION_ID*/
10527    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
10528    if(qosIeExt)
10529    {
10530       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
10531       {
10532          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
10533                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
10534          {
10535             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
10536             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
10537          }
10538       }
10539    }
10540    qosToAdd->ulPduSessAggMaxBitRate = 0;
10541 }
10542
10543 /*******************************************************************
10544  *
10545  * @brief Function to extract GTP Tunnel Info from CU
10546  *
10547  * @details
10548  *
10549  *    Function : extractUpTnlInfo
10550  *
10551  *    Functionality: Function to extract GTP Tunnel Info from CU
10552  *
10553  * @params[in] F1AP message
10554  * @return ROK/RFAILED
10555  *
10556  * ****************************************************************/
10557
10558 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
10559    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
10560 {
10561    uint8_t tnlIdx;
10562    uint32_t ipv4_du = 0;
10563    GTPTunnel_t *gtpTunnel = NULLP;
10564
10565    upTnlInfo->drbId = drbId;
10566    upTnlInfo->configType = configType;
10567 #ifdef O1_ENABLE
10568    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
10569 #else
10570    ipv4_du = duCfgParam.egtpParams.localIp.ipV4Addr;
10571 #endif
10572
10573    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
10574    {
10575       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
10576       {
10577          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
10578          {
10579             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
10580             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
10581             if(upTnlInfo->tnlCfg1 == NULLP)
10582             {
10583                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
10584                return RFAILED;
10585             }
10586             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
10587             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
10588             if(gtpTunnel->gTP_TEID.size > 0)
10589             {
10590                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
10591             }
10592          }
10593          break;
10594       }
10595    }
10596    return ROK;
10597 }
10598
10599 /*******************************************************************
10600 *
10601 * @brief Function to extract Drb Qos Cfg Info from CU
10602 *
10603 * @details
10604 *
10605 *    Function : extractDrbQosCfg
10606 *
10607 *    Functionality: Function to extract Drb Qos Cfg Info from CU
10608 *
10609 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
10610 * @return ROK/RFAILED
10611 *
10612 * ****************************************************************/
10613
10614 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
10615 {
10616    if(!macLcToAdd->drbQos)
10617    {
10618       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
10619       if(macLcToAdd->drbQos == NULLP)
10620       {
10621          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
10622          return RFAILED;
10623       }
10624
10625    }
10626    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
10627    {
10628       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
10629       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
10630    }
10631    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
10632    {
10633       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
10634       return RFAILED;
10635    }
10636    return ROK;
10637 }
10638 /*******************************************************************
10639  *
10640  * @brief Function to extract DRB info received from CU
10641  *
10642  * @details
10643  *
10644  *    Function : extractDrbCfg
10645  *
10646  *    Functionality: Function to extract DRB info received from CU
10647  *
10648  * @params[in] F1AP message
10649  * @return void
10650  *
10651  * ****************************************************************/
10652 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
10653 DRBs_ToBeModified_Item_t *drbModItem,  DuLcCfg *lcCfgToAdd, UpTnlCfg *upTnlInfo)
10654 {
10655    DRB_Information_t *drbInfo = NULLP;
10656
10657    if(drbItem != NULLP)
10658    {
10659       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
10660       {
10661          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10662          return RFAILED;
10663       }
10664       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10665       {
10666          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
10667          {
10668             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10669             if(extractDrbQosCfg(drbInfo , &lcCfgToAdd->lcConfig) != ROK)
10670             {
10671                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10672                return RFAILED;
10673             }
10674          }
10675       }
10676    }
10677    else if(drbSetupModItem != NULLP)
10678    {
10679       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
10680       upTnlInfo) != ROK)
10681       {
10682          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10683          return RFAILED;
10684       }
10685       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10686       {
10687          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
10688          QoSInformation_ExtIEs__value_PR_DRB_Information)
10689          {
10690             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10691             if(extractDrbQosCfg(drbInfo , &lcCfgToAdd->lcConfig) != ROK)
10692             {
10693                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10694                return RFAILED;
10695             }
10696
10697          }
10698       }
10699    }
10700    else if(drbModItem != NULLP)
10701    {
10702       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
10703       upTnlInfo) != ROK)
10704       {
10705          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10706          return RFAILED;
10707       }
10708       if(drbModItem->qoSInformation != NULLP)
10709       {
10710          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
10711          {
10712             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
10713                   QoSInformation_ExtIEs__value_PR_DRB_Information)
10714             {
10715                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10716                if(extractDrbQosCfg(drbInfo , &lcCfgToAdd->lcConfig) != ROK)
10717                {
10718                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10719                   return RFAILED;
10720                }
10721
10722             }
10723          }
10724       }
10725    }
10726    return ROK;
10727 }
10728
10729 /*******************************************************************
10730  *
10731  * @brief Function to extract RB info received from CU
10732  *
10733  * @details
10734  *
10735  *    Function : extractMacRbCfg
10736  *
10737  *    Functionality: Function to extract RB info received from CU
10738  *
10739  * @params[in] F1AP message
10740  * @return ROK/RFAILED
10741  *
10742  * ****************************************************************/
10743
10744 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
10745 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, DuLcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10746 {
10747    if(drbCfg != NULLP)
10748    {
10749       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
10750       {
10751          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10752          return RFAILED;
10753       }
10754    }
10755    else if(drbSetupModCfg != NULLP)
10756    {
10757       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
10758       {
10759          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10760          return RFAILED;
10761       }
10762    }
10763    else if(drbModCfg != NULLP)
10764    {
10765       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
10766       {
10767          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10768          return RFAILED;
10769       }
10770    }
10771    else
10772    {
10773       lcCfg->lcConfig.drbQos = NULLP;
10774       lcCfg->lcConfig.snssai = NULLP;
10775       if(lcCfg->lcConfig.lcId == SRB2_LCID)
10776          lcCfg->lcConfig.dlLcCfg.lcp = LC_PRIORITY_3;
10777       else
10778          lcCfg->lcConfig.dlLcCfg.lcp = LC_PRIORITY_1;
10779
10780    }
10781    if(ulLcCfg)
10782    {
10783       lcCfg->lcConfig.ulLcCfgPres = true;
10784       extractUlLcCfg(&lcCfg->lcConfig.ulLcCfg, ulLcCfg);
10785    }
10786    else
10787       lcCfg->lcConfig.ulLcCfgPres = false;
10788    return ROK;
10789 }
10790
10791 /*******************************************************************
10792  *
10793  * @brief Function processing LC config info received from CU
10794  *
10795  * @details
10796  *
10797  *    Function : procMacLcCfg
10798  *
10799  *    Functionality: Function processing LC config info received from CU
10800  *
10801  * @params[in] F1AP message
10802  * @return ROK/RFAILED
10803  *
10804  * ****************************************************************/
10805
10806 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
10807 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
10808 DuLcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10809 {
10810    uint8_t ret = ROK;
10811
10812    lcCfg->lcConfig.lcId = lcId;
10813    lcCfg->configType = configType;
10814    if(rbType == RB_TYPE_SRB)
10815    {
10816       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
10817    }
10818    else if(rbType == RB_TYPE_DRB && upTnlInfo != NULLP)
10819    {
10820       if(drbItem != NULL)
10821         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
10822       else if(drbSetupModItem != NULL)
10823         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
10824       else if(drbModItem != NULL)
10825         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
10826    }
10827    return ret;
10828 }
10829
10830 /*******************************************************************
10831  *
10832  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
10833  *
10834  * @details
10835  *
10836  *    Function : extractRlcCfgToAddMod
10837  *
10838  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
10839  *
10840  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
10841  *             DuUeCfg Pointer
10842  * @return ROK/RFAILED
10843  *
10844  * ****************************************************************/
10845
10846 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
10847 {
10848   uint8_t idx, rbId, lcId, rlcMode, rbType;
10849   RLC_Config_t *f1RlcCfg = NULLP;
10850   LogicalChannelConfig_t *macUlLcCfg = NULLP;
10851
10852   for(idx = 0; idx < lcCfg->list.count; idx++)
10853   {
10854      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
10855      if(lcCfg->list.array[idx]->servedRadioBearer)
10856      {
10857         /* RadioBearer for SRB/DRB */
10858         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10859         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
10860         {
10861            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
10862            rbType = RB_TYPE_SRB;
10863         }
10864         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10865         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
10866         {
10867            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
10868            rbType = RB_TYPE_DRB;
10869         }
10870         else
10871         {
10872            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
10873            return RFAILED;
10874         }
10875         /* MAC UL LC Config */
10876         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
10877         {
10878            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
10879         }
10880      }
10881      else
10882      {
10883         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
10884         return RFAILED;
10885      }
10886      /* RLC Mode Config */
10887      if(lcCfg->list.array[idx]->rlc_Config)
10888      {
10889         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
10890         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
10891      }
10892
10893      /* Filling RLC/MAC Config*/
10894      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(DuLcCfg));
10895      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(DuRlcBearerCfg));
10896      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
10897      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
10898      {
10899         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
10900         return RFAILED;
10901      }
10902      (ueCfgDb->numRlcLcs)++;
10903      (ueCfgDb->numMacLcs)++;
10904      DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10905         rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10906   }
10907   //TODO: To send the failure cause in UeContextSetupRsp
10908   return ROK;
10909 }
10910
10911 /*******************************************************************
10912  *
10913  * @brief DeAlloc pdsch serv cell config info
10914  *
10915  * @details
10916  *
10917  *    Function : freeMacPdschServCellInfo
10918  *
10919  *    Functionality: DeAlloc pdsch serv cell config info
10920  *
10921  * @params[in] PdschServCellCfg pointer
10922  * @return void
10923  *
10924  * ****************************************************************/
10925
10926 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
10927 {
10928    if(pdsch->xOverhead)
10929    {
10930       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
10931    }
10932    if(pdsch->codeBlkGrpFlushInd)
10933    {
10934       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
10935    }
10936    if(pdsch->maxCodeBlkGrpPerTb)
10937    {
10938       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
10939    }
10940    if(pdsch->maxMimoLayers)
10941    {
10942       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
10943    }
10944 }
10945
10946 /*******************************************************************
10947  *
10948  * @brief Free Serving cell Info
10949  *
10950  * @details
10951  *
10952  *    Function : freeMacServingCellInfo
10953  *
10954  *    Functionality: Free Serving cell Info
10955  *
10956  * @params[in] ServCellCfgInfo *srvCellCfg
10957  * @return void
10958  *
10959  * ****************************************************************/
10960 void freeMacServingCellInfo(ServCellRecfgInfo *srvCellCfg)
10961 {
10962    uint8_t timeDomRsrcIdx;
10963
10964    if(srvCellCfg->initDlBwp.pdschPresent)
10965    {
10966       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
10967       {
10968          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
10969             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
10970       }
10971    }
10972
10973    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
10974    if(srvCellCfg->bwpInactivityTmr)
10975    {
10976       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
10977    }
10978
10979    if(srvCellCfg->initUlBwp.pucchPresent)
10980    {
10981       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10982    }
10983 }
10984
10985 /*******************************************************************
10986  *
10987  * @brief Free cell Grp Cfg Info
10988  *
10989  * @details
10990  *
10991  *    Function : freeUeRecfgCellGrpInfo
10992  *
10993  *    Functionality: Free cell Grp Cfg Info
10994  *
10995  * @params[in] DuMacUeCfg*  duUeCfg
10996  * @return void
10997  *
10998  * ****************************************************************/
10999
11000 void freeUeRecfgCellGrpInfo(DuMacUeCfg *macUeCfg)
11001 {
11002    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
11003 }
11004
11005 /*******************************************************************
11006  *
11007  * @brief Fills Reconfig SchReqReConfig
11008  *
11009  * @details
11010  *
11011  *    Function : extractSchReqReConfig
11012  *
11013  *    Functionality: Fills Reconfig SchReqReConfig
11014  *
11015  * @params[in] SchedulingRequestConfig_t *cuSchedReq
11016  *             SchedReqCfg*  macSchedReq
11017  * @return void
11018  *
11019  * ****************************************************************/
11020 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
11021 {
11022    uint8_t schReqIdx = 0;
11023    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
11024    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
11025
11026    if(cuSchedReq->schedulingRequestToAddModList)
11027    {
11028       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
11029       if(schReqListToAdd->list.count)
11030       {
11031          macSchedReq->addModListCount = schReqListToAdd->list.count;
11032          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
11033          {
11034             macSchedReq->addModList[schReqIdx].schedReqId = \
11035                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
11036             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
11037                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
11038             macSchedReq->addModList[schReqIdx].srTransMax    =\
11039                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
11040          }
11041       }
11042    }
11043    /* Scheduling Req To release */
11044    if(cuSchedReq->schedulingRequestToReleaseList)
11045    {
11046       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
11047       if(schReqListToRel->list.count)
11048       {
11049          macSchedReq->relListCount = schReqListToRel->list.count;
11050          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
11051          {
11052             macSchedReq->relList[schReqIdx] = \
11053                *schReqListToRel->list.array[schReqIdx];
11054          }
11055       }
11056    }
11057 }
11058
11059 /*******************************************************************
11060  *
11061  * @brief Fills TagReconfig
11062  *
11063  * @details
11064  *
11065  *    Function : extractTagReconfig
11066  *
11067  *    Functionality: Fills extractTagReconfig
11068  *
11069  * @params[in] TAG_Config_t *cuTagCfg
11070  *             TagCfg *macTagCfg
11071  * @return void
11072  *
11073  * ****************************************************************/
11074
11075 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
11076 {
11077   uint8_t tagIdx = 0;
11078   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
11079   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
11080
11081   /* Tag config to AddMod */
11082   if(cuTagCfg->tag_ToAddModList)
11083   {
11084      tagListToAddMod = cuTagCfg->tag_ToAddModList;
11085      if(tagListToAddMod->list.count)
11086      {
11087         macTagCfg->addModListCount = tagListToAddMod->list.count;
11088         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
11089         {
11090            macTagCfg->addModList[tagIdx].tagId =\
11091               tagListToAddMod->list.array[tagIdx]->tag_Id;
11092            macTagCfg->addModList[tagIdx].timeAlignTimer = \
11093
11094               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
11095         }
11096      }
11097   }
11098   /* Tag config to release */
11099   if(cuTagCfg->tag_ToReleaseList)
11100   {
11101      tagListToRel = cuTagCfg->tag_ToReleaseList;
11102      if(tagListToRel->list.count)
11103      {
11104         macTagCfg->relListCount = tagListToRel->list.count;
11105         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
11106         {
11107            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
11108         }
11109      }
11110   }
11111 }
11112
11113 /*******************************************************************
11114  *
11115  * @brief Fills SlotOffset value for SearchSpace received by CU
11116  *
11117  * @details
11118  *
11119  *    Function : extractSlotOffset
11120  *
11121  *    Functionality: Fills SlotOffset received  by CU
11122  *
11123  * @params[in] SearchSpace__monitoringSlotPeriodicityAndOffset *mSlotPeriodicityOffset,
11124  *             uint16_t *slotOffset
11125  * @return void
11126  *
11127  *
11128  ****************************************************************/
11129 void extractSlotOffset(struct SearchSpace__monitoringSlotPeriodicityAndOffset *mSlotPeriodicityAndOffset, uint16_t *slotOffset)
11130 {
11131    switch(mSlotPeriodicityAndOffset->present)
11132    {
11133       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_NOTHING:
11134          *slotOffset = NULLD;
11135          break;
11136       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1:
11137          *slotOffset = mSlotPeriodicityAndOffset->choice.sl1;
11138          break;
11139       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl2:
11140          *slotOffset = mSlotPeriodicityAndOffset->choice.sl2;
11141          break;
11142       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl4:
11143          *slotOffset = mSlotPeriodicityAndOffset->choice.sl4;
11144          break;
11145       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl5:
11146          *slotOffset = mSlotPeriodicityAndOffset->choice.sl5;
11147          break;
11148       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl8:
11149          *slotOffset = mSlotPeriodicityAndOffset->choice.sl8;
11150          break;
11151       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl10:
11152          *slotOffset = mSlotPeriodicityAndOffset->choice.sl10;
11153          break;
11154       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl16:
11155          *slotOffset = mSlotPeriodicityAndOffset->choice.sl16;
11156          break;
11157       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl20:
11158          *slotOffset = mSlotPeriodicityAndOffset->choice.sl20;
11159          break;
11160       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl40:
11161          *slotOffset = mSlotPeriodicityAndOffset->choice.sl40;
11162          break;
11163       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl80:
11164          *slotOffset = mSlotPeriodicityAndOffset->choice.sl80;
11165          break;
11166       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl160:
11167          *slotOffset = mSlotPeriodicityAndOffset->choice.sl160;
11168          break;
11169       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl320:
11170          *slotOffset = mSlotPeriodicityAndOffset->choice.sl320;
11171          break;
11172       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl640:
11173          *slotOffset = mSlotPeriodicityAndOffset->choice.sl640;
11174          break;
11175       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1280:
11176          *slotOffset = mSlotPeriodicityAndOffset->choice.sl1280;
11177          break;
11178       case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl2560:
11179          *slotOffset = mSlotPeriodicityAndOffset->choice.sl2560;
11180          break;
11181       default:
11182          *slotOffset = 0;
11183    }
11184 }
11185
11186
11187 /*******************************************************************
11188  *
11189  * @brief Fills PdcchCfg received by CU
11190  *
11191  * @details
11192  *
11193  *    Function : extractPdcchCfg
11194  *
11195  *    Functionality: Fills PdcchCfg received  by CU
11196  *
11197  * @params[in] PDCCH_Config_t *cuPdcchCfg,
11198  *             PdcchConfig *duPdcchCfg
11199  * @return void
11200  *
11201  * ****************************************************************/
11202
11203 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
11204 {
11205    uint8_t cRsetIdx = 0;
11206    uint8_t srchSpcIdx = 0;
11207
11208    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
11209    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
11210    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
11211    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
11212
11213
11214    /* Control Resource Set To Add/Mod List */
11215    if(cuPdcchCfg->controlResourceSetToAddModList)
11216    {
11217       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
11218       if(cRsetToAddModList->list.count)
11219       {
11220          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
11221          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
11222          {
11223             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
11224                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
11225             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
11226                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
11227             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
11228                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
11229                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
11230
11231             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
11232                 cRsetToAddModList->list.array[cRsetIdx]->duration;
11233
11234             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
11235                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
11236             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
11237             {
11238                //TODO: handle the case for Interleaved
11239             }
11240             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
11241                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
11242             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
11243             {
11244                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
11245                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
11246             }
11247          }
11248       }
11249    }
11250    /* Control Resource Set To Release List */
11251    if(cuPdcchCfg->controlResourceSetToReleaseList)
11252    {
11253       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
11254       if(cRsetToRelList->list.count)
11255       {
11256          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
11257          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
11258          {
11259             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
11260          }
11261       }
11262    }
11263
11264    /* Search space To Add/Mod List */
11265    if(cuPdcchCfg->searchSpacesToAddModList)
11266    {
11267       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
11268       if(srchSpcToAddModList->list.count)
11269       {
11270          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
11271          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
11272          {
11273             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
11274                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
11275             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
11276                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
11277             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
11278             {
11279                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset.mSlotPeriodicity =\
11280                                                srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
11281                extractSlotOffset(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset,\
11282                                                &macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset.mSlotOffset);
11283             }
11284             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
11285             {
11286                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
11287                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
11288             }
11289             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
11290             {
11291                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
11292                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
11293                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
11294                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
11295                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
11296                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
11297
11298                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
11299                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
11300
11301                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
11302                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
11303             }
11304             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
11305             {
11306                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
11307                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
11308                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
11309                {
11310                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
11311                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
11312                }
11313
11314             }
11315          }
11316       }
11317    }
11318    /* Search space To Rel List */
11319    if(cuPdcchCfg->searchSpacesToReleaseList)
11320    {
11321       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
11322       if(srchSpcToRelList->list.count)
11323       {
11324          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
11325          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
11326          {
11327             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
11328                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
11329          }
11330       }
11331    }
11332 }
11333
11334 /*******************************************************************
11335  *
11336  * @brief Fills PdschCfg received by CU
11337  *
11338  * @details
11339  *
11340  *    Function : extractPdschCfg
11341  *
11342  *    Functionality: Fills PdschCfg received  by CU
11343  *
11344  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
11345  *                   which we have stored in F1UeContextSetupDb,
11346  *             PdschConfig *macPdschCfg = Used to Store the information which
11347  *                   needs to send in other layer, as well as this can be the variable
11348  *                   which stores the information in DuCb,
11349  *             PdschConfig *storedPdschCfg =  Null in case of sending the
11350  *                   information to other layer else it will have stored pdsch
11351  *                   configuration in copyOfmacUeCfg.
11352  * @return void
11353  *
11354  * ****************************************************************/
11355
11356 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
11357 {
11358    uint8_t timeDomIdx;
11359    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
11360
11361    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
11362    {
11363       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
11364             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
11365       {
11366          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
11367          {
11368             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
11369                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
11370          }
11371       }
11372    }
11373    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
11374    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
11375    {
11376       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
11377       if(timeDomAlloc->present ==\
11378             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
11379       {
11380          if(timeDomAlloc->choice.setup)
11381          {
11382             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
11383             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
11384             {
11385                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
11386                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
11387                {
11388                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
11389                   {
11390                      if(storedPdschCfg)
11391                      {
11392                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
11393                         {
11394                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
11395                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
11396                         }
11397                         else
11398                         {
11399                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
11400                         }
11401                      }
11402                      else
11403                      {
11404                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
11405                      }
11406                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
11407                      {
11408                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
11409                         return;
11410                      }
11411                   }
11412                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
11413                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
11414                }
11415                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
11416                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
11417                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
11418                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
11419             }
11420          }
11421       }
11422    }
11423    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
11424    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
11425       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
11426    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
11427    {
11428       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
11429       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
11430       {
11431          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
11432          {
11433             macPdschCfg->bundlingInfo.StaticBundling.size = \
11434                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
11435          }
11436       }
11437    }
11438    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
11439    {
11440       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
11441    }
11442
11443 }
11444
11445 /*******************************************************************
11446  *
11447  * @brief Fills PdschServingCellCfg received by CU
11448  *
11449  * @details
11450  *
11451  *    Function : extractPdschServingCellCfg
11452  *
11453  *    Functionality: Fills PdschCfg received  by CU
11454  *
11455  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
11456  *             PdschServCellCfg *macUePdschSrvCellCfg
11457  * @return ROK/RFAILED
11458  *
11459  * ****************************************************************/
11460
11461 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
11462 {
11463    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
11464    {
11465       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
11466       {
11467          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
11468          {
11469             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
11470                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
11471          }
11472          else
11473          {
11474             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
11475             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
11476             {
11477                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
11478                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
11479             }
11480             else
11481             {
11482                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
11483                return RFAILED;
11484             }
11485          }
11486          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
11487          {
11488             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
11489                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
11490          }
11491          else
11492          {
11493             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
11494             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
11495             {
11496                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
11497                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
11498             }
11499             else
11500             {
11501                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
11502                return RFAILED;
11503             }
11504          }
11505       }
11506    }
11507    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
11508    {
11509       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
11510    }
11511    if(cuPdschSrvCellCfg->ext1)
11512    {
11513       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
11514       {
11515         if(macUePdschSrvCellCfg->maxMimoLayers)
11516         {
11517            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
11518         }
11519         else
11520         {
11521            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
11522            if(macUePdschSrvCellCfg->maxMimoLayers)
11523            {
11524               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
11525            }
11526            else
11527            {
11528               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
11529               return RFAILED;
11530            }
11531         }
11532       }
11533    }
11534    if(cuPdschSrvCellCfg->xOverhead)
11535    {
11536       if(macUePdschSrvCellCfg->xOverhead)
11537       {
11538          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
11539       }
11540       else
11541       {
11542          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
11543          if(macUePdschSrvCellCfg->xOverhead)
11544          {
11545             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
11546          }
11547          else
11548          {
11549             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
11550             return RFAILED;
11551          }
11552       }
11553    }
11554    return ROK;
11555 }
11556
11557 /*******************************************************************
11558  *
11559  * @brief Fills PuschCfg received by CU
11560  *
11561  * @details
11562  *
11563  *    Function : extractPuschCfg
11564  *
11565  *    Functionality: Fills PuschCfg received  by CU
11566  *
11567  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
11568  *             PuschCfg *macPuschCfg
11569  * @return void
11570  *
11571  * ****************************************************************/
11572
11573 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
11574 {
11575    uint8_t timeDomIdx = 0;
11576    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
11577    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
11578
11579    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
11580    {
11581       if(cuPuschCfg->choice.setup)
11582       {
11583          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
11584          {
11585              macPuschCfg->dataScramblingId = \
11586                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
11587          }
11588          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
11589          {
11590             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
11591             {
11592                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
11593                {
11594                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
11595                   if(dmrsUlCfg->dmrs_AdditionalPosition)
11596                   {
11597                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
11598                         *(dmrsUlCfg->dmrs_AdditionalPosition);
11599                   }
11600                   if(dmrsUlCfg->transformPrecodingDisabled)
11601                   {
11602                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
11603                      {
11604                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
11605                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
11606                      }
11607                   }
11608                }
11609             }
11610          }
11611          /*Res Alloc Type for UL */
11612          if(cuPuschCfg->choice.setup->resourceAllocation)
11613          {
11614             macPuschCfg->resourceAllocType = \
11615                cuPuschCfg->choice.setup->resourceAllocation;
11616          }
11617          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
11618          {
11619             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
11620             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
11621             {
11622                if(timeDomAllocList->choice.setup)
11623                {
11624                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
11625                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
11626                   {
11627                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
11628                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
11629                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
11630                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
11631                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
11632                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
11633                   }
11634                }
11635             }
11636          }
11637          if(cuPuschCfg->choice.setup->transformPrecoder)
11638             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
11639       }
11640    }
11641 }
11642
11643 /*******************************************************************
11644  *
11645  * @brief Function to fill pucch Power Control
11646  *
11647  * @details
11648  *
11649  *    Function : extractPucchPowerControl
11650  *
11651  *    Functionality: Function to fill pucch Power Control
11652  *
11653  * @params[in] PucchPowerControl *pwrCtrl,
11654  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
11655  * @return void
11656  *
11657  * ****************************************************************/
11658
11659 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
11660 {
11661    uint8_t arrIdx;
11662
11663    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
11664       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
11665    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
11666       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
11667    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
11668       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
11669    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
11670       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
11671    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
11672       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
11673    if(cuPwrCtrlCfg->p0_Set)
11674    {
11675       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
11676       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
11677       {
11678          pwrCtrl->p0Set[arrIdx].p0PucchId =\
11679             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
11680          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
11681             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
11682       }
11683    }
11684    if(cuPwrCtrlCfg->pathlossReferenceRSs)
11685    {
11686       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
11687       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
11688       {
11689          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
11690             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
11691       }
11692    }
11693 }
11694
11695  /*******************************************************************
11696  *
11697  * @brief Function to extractResrcSetToAddModList sent by CU
11698  *
11699  * @details
11700  *
11701  *    Function : extractResrcSetToAddModList
11702  *
11703  *    Functionality: Fucntion to extractResrcSetToAddModList
11704  *
11705  * @params[in] PucchResrcSetCfg pointer,
11706  *             struct PUCCH_Config__resourceSetToAddModList pointer
11707  * @return void
11708  *
11709  * ****************************************************************/
11710
11711 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
11712 {
11713    uint8_t arrIdx, rsrcListIdx;
11714
11715    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
11716    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
11717    {
11718       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
11719          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
11720       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
11721          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
11722       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
11723       {
11724          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
11725             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
11726       }
11727
11728       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
11729       {
11730          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
11731             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
11732       }
11733       else
11734       {
11735          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
11736       }
11737    }
11738 }/* End of extractResrcSetToAddModList */
11739
11740 /*******************************************************************
11741  *
11742  * @brief Fills extractResrcToAddModList sent by CU
11743  *
11744  * @details
11745  *
11746  *    Function : extractResrcToAddModList
11747  *
11748  *    Functionality: Fills extractResrcToAddModList
11749  *
11750  * @params[in] PucchResrcCfg pointer,
11751  *             struct PUCCH_Config__resourceToAddModList pointer
11752  * @return ROk/RFAILED
11753  *
11754  * ****************************************************************/
11755
11756 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
11757 {
11758    uint8_t arrIdx;
11759
11760    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
11761    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
11762    {
11763       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
11764         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
11765       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
11766         cuResrcList->list.array[arrIdx]->startingPRB;
11767       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
11768       {
11769          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
11770            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
11771       }
11772       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
11773       {
11774          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
11775            *cuResrcList->list.array[arrIdx]->secondHopPRB;
11776       }
11777       /* PUCCH RSRC FORMAT */
11778       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
11779       {
11780          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
11781          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
11782          {
11783             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
11784             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
11785             {
11786                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
11787                return RFAILED;
11788             }
11789             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
11790                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
11791             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
11792                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
11793             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
11794                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
11795          }
11796       }
11797       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
11798       {
11799          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
11800          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
11801          {
11802             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
11803             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
11804             {
11805                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
11806                return RFAILED;
11807             }
11808             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
11809                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
11810             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
11811                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
11812             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
11813                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
11814             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
11815                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
11816          }
11817       }
11818       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
11819       {
11820          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
11821          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
11822          {
11823             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
11824             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
11825             {
11826                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
11827                return RFAILED;
11828             }
11829             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
11830                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
11831             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
11832                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
11833             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
11834                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
11835          }
11836       }
11837       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
11838       {
11839          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
11840          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
11841          {
11842             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
11843             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
11844             {
11845                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
11846                return RFAILED;
11847             }
11848             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
11849                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
11850             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
11851                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
11852             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
11853                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
11854          }
11855       }
11856       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
11857       {
11858          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
11859          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
11860          {
11861             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
11862             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
11863             {
11864                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
11865                return RFAILED;
11866             }
11867             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
11868                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
11869             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
11870                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
11871             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
11872                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
11873             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
11874                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
11875          }
11876       }
11877    }
11878    return ROK;
11879
11880 }/* End of extractResrcToAddModList */
11881
11882 /*******************************************************************
11883  *
11884  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
11885  *
11886  * @details
11887  *
11888  *    Function : fillPucchSchedReqPeriodAndOffset
11889  *
11890  *    Functionality: To fillPucchSchedReqPeriodAndOffset
11891  *
11892  * @params[in] macPeriodicty,
11893  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
11894  * @return void
11895  *
11896  * ****************************************************************/
11897
11898 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
11899    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
11900 {
11901    macPeriodicty = cuPeriodicty->present;
11902    switch(macPeriodicty)
11903    {
11904       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
11905          {
11906             macOffset     = cuPeriodicty->choice.sym2;
11907             break;
11908          }
11909       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
11910          {
11911             macOffset     = cuPeriodicty->choice.sym6or7;
11912             break;
11913          }
11914       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
11915          {
11916             macOffset     = cuPeriodicty->choice.sl1;
11917             break;
11918          }
11919       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
11920          {
11921             macOffset = cuPeriodicty->choice.sl2;
11922             break;
11923          }
11924       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
11925          {
11926             macOffset = cuPeriodicty->choice.sl4;
11927             break;
11928          }
11929       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
11930          {
11931             macOffset = cuPeriodicty->choice.sl5;
11932             break;
11933          }
11934       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
11935          {
11936             macOffset = cuPeriodicty->choice.sl8;
11937             break;
11938          }
11939       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
11940          {
11941             macOffset = cuPeriodicty->choice.sl10;
11942             break;
11943          }
11944       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
11945          {
11946             macOffset = cuPeriodicty->choice.sl16;
11947             break;
11948          }
11949       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
11950          {
11951             macOffset = cuPeriodicty->choice.sl20;
11952             break;
11953          }
11954       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
11955          {
11956             macOffset = cuPeriodicty->choice.sl40;
11957             break;
11958          }
11959       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
11960          {
11961             macOffset = cuPeriodicty->choice.sl80;
11962             break;
11963          }
11964       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
11965          {
11966             macOffset = cuPeriodicty->choice.sl160;
11967             break;
11968          }
11969       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
11970          {
11971             macOffset = cuPeriodicty->choice.sl320;
11972             break;
11973          }
11974       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
11975          {
11976             macOffset = cuPeriodicty->choice.sl640;
11977             break;
11978          }
11979       default :
11980          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
11981    }
11982 }
11983
11984 /*******************************************************************
11985  *
11986  * @brief Function to extractPucchFormatCfg sent by CU
11987  *
11988  * @details
11989  *
11990  *    Function : extractPucchFormatCfg
11991  *
11992  *    Functionality: Function to extractPucchFormatCfg
11993  *
11994  * @params[in] PucchFormatCfg pointer,
11995  *             PUCCH_FormatConfig_t pointer
11996  * @return void
11997  *
11998  * ****************************************************************/
11999
12000 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
12001  {
12002     if(cuFormatCfg->interslotFrequencyHopping)
12003        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
12004     if(cuFormatCfg->additionalDMRS)
12005        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
12006     if(cuFormatCfg->maxCodeRate)
12007        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
12008     if(cuFormatCfg->nrofSlots)
12009        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
12010     if(cuFormatCfg->pi2BPSK)
12011        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
12012     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
12013        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
12014  }/* End of extractPucchFormatCfg */
12015
12016 /*******************************************************************
12017  *
12018  * @brief Function to extractSchedReqCfgToAddMod sent by CU
12019  *
12020  * @details
12021  *
12022  *    Function : extractSchedReqCfgToAddMod
12023  *
12024  *    Functionality: Function to extractSchedReqCfgToAddMod
12025  *
12026  * @params[in] PucchSchedReqCfg pointer,
12027  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
12028  * @return void
12029  *
12030  * ****************************************************************/
12031
12032 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
12033 {
12034    uint8_t arrIdx;
12035
12036    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
12037    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
12038    {
12039       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
12040          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
12041       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
12042          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
12043       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
12044       {
12045          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
12046             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
12047       }
12048       if(cuSchedReqList->list.array[arrIdx]->resource)
12049       {
12050          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
12051             *cuSchedReqList->list.array[arrIdx]->resource;
12052       }
12053    }
12054
12055 }/* End of extractSchedReqCfgToAddMod */
12056
12057  /*******************************************************************
12058  *
12059  * @brief Fills PucchCfg received by CU
12060  *
12061  * @details
12062  *
12063  *    Function : extractPucchCfg
12064  *
12065  *    Functionality: Fills PucchCfg received  by CU
12066  *
12067  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
12068  *                is send by CU, which we have stored in F1UeContextSetupDb,
12069  *             PucchCfg *macPucchCfg = Used to Store the information which
12070  *                needs to send in other layer, as well as this can be the variable
12071  *                which stores the information in DuCb,
12072  *             PucchCfg *storedPucchCfg = Null in case of sending the
12073  *                information to other layer else it will have Pucch Cfg which
12074  *                we have stored in copyOfmacUeCfg.
12075  * @return ROK/RFAILED
12076  *
12077  * ****************************************************************/
12078
12079 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
12080 PucchCfg *storedPucchCfg)
12081 {
12082    uint8_t arrIdx;
12083
12084    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
12085    {
12086       if(cuPucchCfg->choice.setup)
12087       {
12088          /* Resource Set Cfg */
12089          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
12090          {
12091             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
12092             if(macPucchCfg->resrcSet == NULLP)
12093             {
12094                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
12095                return RFAILED;
12096             }
12097             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
12098             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
12099          }
12100
12101          /* Resource Cfg */
12102          if(cuPucchCfg->choice.setup->resourceToAddModList)
12103          {
12104             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
12105             if(macPucchCfg->resrc == NULLP)
12106             {
12107                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
12108                return RFAILED;
12109             }
12110             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
12111             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
12112          }
12113
12114          /* Format 1 Cfg */
12115          if(cuPucchCfg->choice.setup->format1)
12116          {
12117             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
12118             if(macPucchCfg->format1 == NULLP)
12119             {
12120                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
12121                return RFAILED;
12122             }
12123             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
12124             extractPucchFormatCfg(macPucchCfg->format1,\
12125                cuPucchCfg->choice.setup->format1->choice.setup);
12126          }
12127
12128          /* Format 2 Cfg */
12129          if(cuPucchCfg->choice.setup->format2)
12130          {
12131             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
12132             if(macPucchCfg->format2 == NULLP)
12133             {
12134                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
12135                return RFAILED;
12136             }
12137             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
12138             extractPucchFormatCfg(macPucchCfg->format2,\
12139                cuPucchCfg->choice.setup->format2->choice.setup);
12140          }
12141
12142          /* Format 3 Cfg */
12143          if(cuPucchCfg->choice.setup->format3)
12144          {
12145             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
12146             if(macPucchCfg->format3 == NULLP)
12147             {
12148                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
12149                return RFAILED;
12150             }
12151             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
12152             extractPucchFormatCfg(macPucchCfg->format3,\
12153                cuPucchCfg->choice.setup->format3->choice.setup);
12154          }
12155
12156          /* Format 4 Cfg */
12157          if(cuPucchCfg->choice.setup->format4)
12158          {
12159             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
12160             if(macPucchCfg->format4 == NULLP)
12161             {
12162                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
12163                return RFAILED;
12164             }
12165             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
12166             extractPucchFormatCfg(macPucchCfg->format4,\
12167                cuPucchCfg->choice.setup->format4->choice.setup);
12168          }
12169
12170          /* Sched Req List */
12171          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
12172          {
12173             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
12174             if(macPucchCfg->schedReq == NULLP)
12175             {
12176                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
12177                return RFAILED;
12178             }
12179             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
12180             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
12181             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
12182          }
12183
12184          /*TODO: Add support for  Spatial Info */
12185
12186          /* MultiCsiCfg */
12187          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
12188          {
12189             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
12190             if(macPucchCfg->multiCsiCfg == NULLP)
12191             {
12192                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
12193                return RFAILED;
12194             }
12195             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
12196             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
12197             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
12198             {
12199                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
12200                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
12201             }
12202          }
12203
12204          /* Dl_DataToUL_ACK */
12205          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
12206     {
12207        if(storedPucchCfg)
12208        {
12209           if(storedPucchCfg->dlDataToUlAck)
12210           {
12211              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
12212           }
12213           else
12214           {
12215             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
12216           }
12217        }
12218        else
12219        {
12220           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
12221        }
12222        if(macPucchCfg->dlDataToUlAck == NULLP)
12223        {
12224           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
12225           return RFAILED;
12226        }
12227        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
12228        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
12229        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
12230        {
12231           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
12232           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
12233        }
12234          }
12235
12236          /* Power Control */
12237          if(cuPucchCfg->choice.setup->pucch_PowerControl)
12238          {
12239             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
12240             if(macPucchCfg->powerControl == NULLP)
12241             {
12242                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
12243                return RFAILED;
12244             }
12245             extractPucchPowerControl(macPucchCfg->powerControl,\
12246                cuPucchCfg->choice.setup->pucch_PowerControl);
12247          }
12248       }
12249    }
12250    return ROK;
12251 }
12252
12253 /*******************************************************************
12254  *
12255  * @brief Fills ServingCellReconfig received by CU
12256  *
12257  * @details
12258  *
12259  *    Function : extractSpCellDedicatedCfg
12260  *
12261  *    Functionality: Fills ServingCellReconfig received  by CU
12262  *
12263  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
12264  *                  CU, which we have stored in F1UeContextSetupDb,
12265  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
12266  *                  which  needs to send in other layer, as well as this can be the
12267  *                  variable which stores the information in DuCb,
12268  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
12269  *                  information to other layer else it will have ServCellCfgInfo which
12270  *                  we have stored in copyOfmacUeCfg.
12271  * @return ROK/RFAILD
12272  *
12273  * ****************************************************************/
12274 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellRecfgInfo *macSrvCellCfg,\
12275 ServCellRecfgInfo *storedSrvCellCfg)
12276 {
12277    uint8_t ret = ROK;
12278    BWP_DownlinkDedicated_t *dlBwp = NULLP;
12279    BWP_UplinkDedicated_t   *ulBwp = NULLP;
12280
12281    if(cuSrvCellCfg->initialDownlinkBWP)
12282    {
12283       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
12284       if(dlBwp->pdcch_Config)
12285       {
12286          if(dlBwp->pdcch_Config->choice.setup)
12287          {
12288             macSrvCellCfg->initDlBwp.pdcchPresent = true;
12289             if(storedSrvCellCfg)
12290             {
12291                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
12292                {
12293                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
12294                }
12295                else
12296                {
12297                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
12298                }
12299             }
12300             else
12301             {
12302                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
12303             }
12304          }
12305       }
12306       if(dlBwp->pdsch_Config)
12307       {
12308          if(dlBwp->pdsch_Config->choice.setup)
12309          {
12310             macSrvCellCfg->initDlBwp.pdschPresent = true;
12311
12312             if(storedSrvCellCfg)
12313             {
12314                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
12315                {
12316                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
12317                }
12318                else
12319                {
12320                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
12321                         &storedSrvCellCfg->initDlBwp.pdschCfg);
12322                }
12323             }
12324             else
12325             {
12326                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
12327             }
12328          }
12329       }
12330    }
12331    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
12332       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
12333    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
12334       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
12335    if(cuSrvCellCfg->bwp_InactivityTimer)
12336    {
12337       if(macSrvCellCfg->bwpInactivityTmr)
12338       {
12339          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
12340       }
12341       else
12342       {
12343          macSrvCellCfg->bwpInactivityTmr = NULLP;
12344          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
12345          if(macSrvCellCfg->bwpInactivityTmr)
12346          {
12347             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
12348          }
12349          else
12350          {
12351             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
12352             return RFAILED;
12353          }
12354       }
12355    }
12356    if(cuSrvCellCfg->pdsch_ServingCellConfig)
12357    {
12358       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
12359       {
12360          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
12361          if(ret == RFAILED)
12362          {
12363             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
12364             return RFAILED;
12365          }
12366       }
12367    }
12368    if(cuSrvCellCfg->uplinkConfig)
12369    {
12370       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
12371       {
12372          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
12373          if(ulBwp->pusch_Config)
12374          {
12375             macSrvCellCfg->initUlBwp.puschPresent = true;
12376             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
12377          }
12378          if(ulBwp->pucch_Config)
12379          {
12380             macSrvCellCfg->initUlBwp.pucchPresent = true;
12381             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
12382             if(storedSrvCellCfg)
12383             {
12384                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
12385                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
12386                else
12387                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
12388                   &storedSrvCellCfg->initUlBwp.pucchCfg);
12389             }
12390             else
12391             {
12392                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
12393             }
12394          }
12395       }
12396       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
12397          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
12398    }
12399    return ret;
12400 }
12401
12402 #ifdef NR_DRX
12403
12404 /*******************************************************************
12405  *
12406  * @brief fill long cycle offset value of drx in UE structure
12407  *
12408  * @details
12409  *
12410  *    Function : fillLongCycleOffsetValueInUeDb
12411  *
12412  *    Functionality: fill long cycle offset value of drx in UE structure
12413  *
12414  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
12415  * struct DRX_ConfigRrc__drx_LongCycleStartOffset drx_LongCycleStartOffset
12416  *
12417  * @return ROK     - success
12418  *         RFAILED - failure
12419  *
12420  * ****************************************************************/
12421 void fillLongCycleOffsetValueInUeDb(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__drx_LongCycleStartOffset  *drx_LongCycleStartOffset)
12422 {
12423
12424    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = convertLongDrxCycleLengthEnumToValue(drx_LongCycleStartOffset->present);
12425    switch(drx_LongCycleStartOffset->present)
12426    {
12427       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
12428          {
12429             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms10;
12430             break;
12431          }
12432       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
12433          {
12434             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms20;
12435             break;
12436          }
12437       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
12438          {
12439             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms32;
12440             break;
12441          }
12442       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
12443         {
12444             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms40;
12445             break;
12446          }
12447       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
12448          {
12449             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms60;
12450             break;
12451          }
12452       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
12453          {
12454             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms64;
12455             break;
12456          }
12457       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
12458          {
12459             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms70;
12460             break;
12461          }
12462       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
12463          {
12464             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms80;
12465             break;
12466          }
12467       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
12468          {
12469             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms128;
12470             break;
12471          }
12472       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
12473          {
12474             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms160;
12475             break;
12476          }
12477       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
12478          {
12479             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms256;
12480             break;
12481          }
12482       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
12483          {
12484             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms320;
12485             break;
12486          }
12487       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
12488          {
12489             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms512;
12490             break;
12491          }
12492       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
12493          {
12494             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms640;
12495             break;
12496          }
12497       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
12498          {
12499             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms1024;
12500             break;
12501          }
12502       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
12503          {
12504             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms1280;
12505             break;
12506          }
12507       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
12508          {
12509             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms2048;
12510             break;
12511          }
12512       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
12513          {
12514             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms2560;
12515             break;
12516          }
12517        case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
12518          {
12519             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms5120;
12520             break;
12521          }
12522       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
12523          {
12524             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms10240;
12525             break;
12526          }
12527       default :
12528          break;
12529    }
12530 }
12531
12532 /*******************************************************************
12533  *
12534  * @brief Fills drx configuration structure with the help of drx_ConfigRrc
12535  *which recive from CU or storedDrxCfg which is already stored
12536  *
12537  * @details
12538  *
12539  *    Function : extractDrxConfiguration
12540  *
12541  *    Functionality: Fills Reconfig Cell group Info received by CU
12542  *
12543  * @params[in] cuMacCellGrpDrxConfig  = MAC_CellGroupConfig__drx_ConfigRrc information which
12544  *                       is send by CU, which we have stored in F1UeContextSetupDb
12545  *             DrxCfg * drxCfg  = Used to Store the information,
12546  *                      which needs to send in other layer, as well as this can be
12547  *                      the variable which stores the information in DuCb,
12548  *             DrxCfg *storedDrxCfg = Null in case of sending the
12549  *                      information to other layer else it will have the drx information
12550  *                      stored in the copyOfmacUeCfg which we have stored in F1UeContextSetupDb.
12551  *
12552  * @return void
12553  *
12554  * ****************************************************************/
12555 void extractDrxConfiguration(struct MAC_CellGroupConfig__drx_ConfigRrc *cuMacCellGrpDrxConfig, DrxCfg * drxCfg, DrxCfg *storedDrxCfg)
12556 {
12557    struct DRX_ConfigRrc *cuDrxConfig;
12558
12559    if(storedDrxCfg)
12560    {
12561       memcpy(drxCfg, storedDrxCfg, sizeof(DrxCfg));
12562    }
12563    else
12564    {
12565       if(cuMacCellGrpDrxConfig)
12566       {
12567          switch(cuMacCellGrpDrxConfig->present)
12568          {
12569             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
12570                break;
12571
12572             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
12573                {
12574                   cuDrxConfig = cuMacCellGrpDrxConfig->choice.setup;
12575                   if(cuDrxConfig)
12576                   {
12577                      switch(cuDrxConfig->drx_onDurationTimer.present)
12578                      {
12579                         case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
12580                            break;
12581                         case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
12582                            {
12583                               drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
12584                               drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=convertOnDurationTimerMilliSecondsEnumToValue(cuDrxConfig->\
12585                               drx_onDurationTimer.choice.milliSeconds);
12586                               break;
12587                            }
12588                         case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
12589                            {
12590                               drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
12591                               drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = cuDrxConfig->drx_onDurationTimer.choice.subMilliSeconds;
12592                               break;
12593                            }
12594                      }
12595                   }
12596                   fillLongCycleOffsetValueInUeDb(&drxCfg->drxLongCycleStartOffset, &cuDrxConfig->drx_LongCycleStartOffset);
12597                   drxCfg->drxInactivityTimer = convertDrxInactivityTimerEnumToValue(cuDrxConfig->drx_InactivityTimer);
12598                   drxCfg->drxHarqRttTimerDl = cuDrxConfig->drx_HARQ_RTT_TimerDL;
12599                   drxCfg->drxHarqRttTimerUl = cuDrxConfig->drx_HARQ_RTT_TimerUL;
12600                   drxCfg->drxRetransmissionTimerDl = convertDrxRetransmissionTimerDlEnumToValue(cuDrxConfig->drx_RetransmissionTimerDL);
12601                   drxCfg->drxRetransmissionTimerUl = convertDrxRetransmissionTimerUlEnumToValue(cuDrxConfig->drx_RetransmissionTimerUL);
12602                   drxCfg->drxSlotOffset = cuDrxConfig->drx_SlotOffset;
12603                   if(cuDrxConfig->shortDRX)
12604                   {
12605                      drxCfg->shortDrxPres=true;
12606                      drxCfg->shortDrx.drxShortCycle = convertShortDrxCycleLengthEnumToValue(cuDrxConfig->shortDRX->drx_ShortCycle);
12607                      drxCfg->shortDrx.drxShortCycleTimer = cuDrxConfig->shortDRX->drx_ShortCycleTimer;
12608                   }
12609                   else
12610                      drxCfg->shortDrxPres=false;
12611
12612                   break;
12613                }
12614
12615             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
12616                break;
12617          }
12618       }
12619    }
12620 }
12621 #endif
12622
12623 /*******************************************************************
12624  *
12625  * @brief Fills Reconfig Cell group Info received by CU
12626  *
12627  * @details
12628  *
12629  *    Function : extractUeRecfgCellInfo
12630  *
12631  *    Functionality: Fills Reconfig Cell group Info received by CU
12632  *
12633  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
12634  *                       is send by CU, which we have stored in F1UeContextSetupDb
12635  *             DuMacUeCfg *MacUeCfg = Used to Store the information,
12636  *                      which needs to send in other layer, as well as this can be
12637  *                      the variable which stores the information in DuCb,
12638  *             DuMacUeCfg *storedMacUeCfg = Null in case of sending the
12639  *                      information to other layer else it will have copyOfmacUeCfg
12640  *                      which we have stored in F1UeContextSetupDb.
12641  *
12642  * @return ROK/RFAILED
12643  *
12644  * ****************************************************************/
12645 uint8_t extractUeRecfgCellInfo(CellGroupConfigRrc_t *cellGrp, DuMacUeCfg *macUeCfg, DuMacUeCfg *storedMacUeCfg)
12646 {
12647    uint8_t ret = ROK;
12648    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
12649    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
12650    SpCellConfig_t            *spcellCfg = NULLP;
12651    ServingCellConfig_t       *servCellCfg = NULLP;
12652
12653    if(cellGrp)
12654    {
12655       /* Fill MacCell Group Reconfig  */
12656       if(cellGrp->mac_CellGroupConfig)
12657       {
12658          macUeCfg->macCellGrpCfgPres = true;
12659          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
12660
12661 #ifdef NR_DRX
12662          if(macCellGroup->drx_ConfigRrc)
12663          {
12664             if(storedMacUeCfg)
12665             {
12666                if(!storedMacUeCfg->macCellGrpCfgPres)
12667                {
12668                   extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg,NULL);
12669                }
12670                else
12671                {
12672                   extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg, &storedMacUeCfg->macCellGrpCfg.drxCfg);
12673                }
12674             }
12675             else
12676             {
12677                extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg,NULL);
12678             }
12679          }
12680 #endif
12681
12682          if(macCellGroup->schedulingRequestConfig)
12683          {
12684             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
12685          }
12686          if(macCellGroup->tag_Config)
12687          {
12688             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
12689          }
12690          if(macCellGroup->bsr_Config)
12691          {
12692             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
12693             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
12694             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
12695             {
12696                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
12697                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
12698             }
12699          }
12700          if(macCellGroup->phr_Config)
12701          {
12702             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
12703             {
12704                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
12705                if(macCellGroup->phr_Config->choice.setup)
12706                {
12707                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
12708                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
12709                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
12710                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
12711                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
12712                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
12713                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
12714                   macCellGroup->phr_Config->choice.setup->multiplePHR;
12715                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
12716                   macCellGroup->phr_Config->choice.setup->dummy;
12717                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
12718                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
12719                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
12720                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
12721                }
12722             }
12723          }
12724       }
12725       /* Fill Physical Cell Group Reconfig */
12726       if(cellGrp->physicalCellGroupConfig)
12727       {
12728          macUeCfg->phyCellGrpCfgPres = true;
12729          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
12730          if(phyCellGrpCfg->p_NR_FR1)
12731          {
12732             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
12733                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
12734          }
12735          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
12736       }
12737       /* Fill SpCell Reconfig */
12738       if(cellGrp->spCellConfig)
12739       {
12740          macUeCfg->spCellCfgPres = true;
12741          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
12742          if(spcellCfg->servCellIndex)
12743          {
12744             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
12745          }
12746          /* Fill Serving cell Reconfig info */
12747          if(cellGrp->spCellConfig->spCellConfigDedicated)
12748          {
12749             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
12750             if(storedMacUeCfg)
12751             {
12752                if(!storedMacUeCfg->spCellCfgPres)
12753                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
12754                else
12755                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
12756                         &storedMacUeCfg->spCellCfg.servCellCfg);
12757             }
12758             else
12759             {
12760                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
12761             }
12762             if(ret == RFAILED)
12763             {
12764                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
12765             }
12766          }
12767       }
12768    }
12769    return ret;
12770 }
12771 /*******************************************************************
12772 *
12773 * @brief free the memory allocated by decoder
12774 *
12775 * @details
12776 *
12777 *    Function : freeAperDecodeNrcgi
12778 *
12779 *    Functionality: Free Nrcgi values
12780 *
12781 * @params[in] NRCGI_t *nrcgi
12782 * @return void
12783 *
12784 * ****************************************************************/
12785
12786
12787 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
12788 {
12789     if(nrcgi->pLMN_Identity.buf != NULLP)
12790     {
12791        free(nrcgi->pLMN_Identity.buf);
12792     }
12793     if(nrcgi->nRCellIdentity.buf != NULLP)
12794     {
12795        free(nrcgi->nRCellIdentity.buf);
12796     }
12797 }
12798 /*******************************************************************
12799 *
12800 * @brief free the memory allocated by decoder
12801 *
12802 * @details
12803 *
12804 *    Function : freeAperDecodeCuToDuInfo
12805 *
12806 *    Functionality:  Free Cu To Du Information
12807 *
12808 * @params[in] CUtoDURRCInformation_t *rrcMsg
12809 * @return void
12810 *
12811 * ****************************************************************/
12812
12813
12814 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
12815 {
12816    uint8_t ieIdx =0;
12817    uint8_t arrIdx =0;
12818
12819    if(rrcMsg->uE_CapabilityRAT_ContainerList)
12820    {
12821       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
12822          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
12823       free(rrcMsg->uE_CapabilityRAT_ContainerList);
12824    }
12825
12826    if(rrcMsg->iE_Extensions)
12827    {
12828       if(rrcMsg->iE_Extensions->list.array)
12829       {
12830          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
12831          {
12832             if(rrcMsg->iE_Extensions->list.array[ieIdx])
12833             {
12834                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
12835                {
12836                   case ProtocolIE_ID_id_CellGroupConfig:
12837                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
12838                      {
12839                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
12840                      }
12841                      break;
12842                   default:
12843                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
12844                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
12845                      break;
12846                }
12847             }
12848          }
12849          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
12850          {
12851             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
12852          }
12853          free(rrcMsg->iE_Extensions->list.array);
12854
12855       }
12856
12857       free(rrcMsg->iE_Extensions);
12858    }
12859 }
12860 /*******************************************************************
12861 *
12862 * @brief free the memory allocated by decoder
12863 *
12864 * @details
12865 *
12866 *    Function : freeAperDecodeSplCellList
12867 *
12868 *    Functionality: Free Spl Cell List
12869                     where memory allocated by aper_decoder
12870 *
12871 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
12872 * @return void
12873 *
12874 * ****************************************************************/
12875
12876
12877 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
12878 {
12879     uint8_t  cellIdx =0;
12880
12881     if(spCellLst->list.array != NULLP)
12882     {
12883        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
12884        {
12885           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
12886           {
12887              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
12888           }
12889           if(spCellLst->list.array[cellIdx]!=NULLP)
12890           {
12891              free(spCellLst->list.array[cellIdx]);
12892           }
12893        }
12894        free(spCellLst->list.array);
12895     }
12896 }
12897 /*******************************************************************
12898 *
12899 * @brief free the memory allocated by decoder
12900 *
12901 * @details
12902 *
12903 *    Function : freeAperDecodeSRBSetup
12904 *
12905 *    Functionality: added free part for the memory allocated by aper_decoder
12906 *
12907 * @params[in] SRBs_ToBeSetup_List_t *srbSet
12908 * @return void
12909 *
12910 ****************************************************************/
12911
12912
12913 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
12914 {
12915     uint8_t srbIdx =0;
12916     if(srbSet->list.array != NULLP)
12917     {
12918        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
12919        {
12920           if(srbSet->list.array[srbIdx]!=NULLP)
12921           {
12922              free(srbSet->list.array[srbIdx]);
12923           }
12924        }
12925        free(srbSet->list.array);
12926     }
12927 }
12928
12929 /*******************************************************************
12930 *
12931 * @brief free the memory allocated by decoder
12932 *
12933 * @details
12934 *
12935 *    Function : freeAperDecodeULTnlInfo
12936 *
12937 *    Functionality: added free part for the memory allocated by aper_decoder
12938 *
12939 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12940 * @return void
12941 *
12942 * ****************************************************************/
12943
12944
12945 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12946 {
12947    uint8_t ulIdx=0;
12948    if(ulInfo->list.array != NULLP)
12949    {
12950       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
12951       {
12952          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
12953          {
12954             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
12955             {
12956                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12957                      transportLayerAddress.buf != NULLP)
12958                {
12959                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
12960                         !=NULLP)
12961                   {
12962                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
12963                   }
12964                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12965                         transportLayerAddress.buf);
12966                }
12967                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
12968             }
12969          }
12970          if(ulInfo->list.array[ulIdx]!=NULLP)
12971          {
12972             free(ulInfo->list.array[ulIdx]);
12973          }
12974       }
12975       free(ulInfo->list.array);
12976    }
12977 }
12978 /*******************************************************************
12979 *
12980 * @brief free the memory allocated by decoder
12981 *
12982 * @details
12983 *
12984 *    Function : freeAperDecodeDRBSetup
12985 *
12986 *    Functionality: free DRBSetup which is allocated by decoder
12987 *
12988 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
12989 * @return void
12990 *
12991 * ****************************************************************/
12992
12993 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
12994 {
12995    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
12996    uint8_t  flowIdx =0;
12997    uint8_t  drbIdx =0;
12998
12999    if(drbSet->list.array != NULLP)
13000    {
13001       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
13002       {
13003          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
13004          {
13005             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
13006             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
13007             {
13008                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
13009                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
13010                {
13011                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
13012                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
13013                   {
13014                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
13015                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
13016                      {
13017
13018                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
13019                         {
13020
13021                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
13022                            {
13023
13024                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
13025                                     buf!=NULLP)
13026                               {
13027
13028                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
13029                                        flows_Mapped_To_DRB_List.list.array != NULLP)
13030                                  {
13031
13032                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13033                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
13034                                     {
13035
13036                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13037                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
13038                                        {
13039                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13040                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
13041                                                 qoSFlowLevelQoSParameters.\
13042                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
13043                                           {
13044                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13045                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
13046                                                    qoSFlowLevelQoSParameters.\
13047                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
13048                                              {
13049
13050                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13051                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
13052                                                       qoSFlowLevelQoSParameters.\
13053                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
13054                                                 {
13055
13056
13057                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13058                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
13059                                                          qoSFlowLevelQoSParameters.\
13060                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
13061                                                 }
13062
13063                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13064                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
13065                                                       qoSFlowLevelQoSParameters.\
13066                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
13067                                              }
13068
13069                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13070
13071                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
13072                                                    qoSFlowLevelQoSParameters.\
13073                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
13074                                           }
13075                                        }
13076                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13077                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
13078                                        {
13079
13080                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13081                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
13082                                        }
13083                                     }
13084
13085                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13086                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
13087                                  }
13088
13089                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
13090                                        DRB_Information.sNSSAI.sD->buf);
13091                               }
13092
13093                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
13094                            }
13095
13096                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
13097
13098                         }
13099
13100                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
13101
13102                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
13103                      }
13104
13105                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
13106                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
13107                   }
13108
13109                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
13110                         qoS_Characteristics.choice.non_Dynamic_5QI);
13111                }
13112                free(drbSetItem->qoSInformation.choice.choice_extension);
13113             }
13114             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
13115             if(drbSetItem->uLConfiguration)
13116             {
13117                free(drbSetItem->uLConfiguration);
13118             }
13119          }
13120          if(drbSet->list.array[drbIdx]!=NULLP)
13121          {
13122             free(drbSet->list.array[drbIdx]);
13123          }
13124       }
13125       free(drbSet->list.array);
13126    }
13127 }
13128
13129
13130 /*******************************************************************
13131  *
13132  * @brief builds Mac Cell Cfg
13133  *
13134  * @details
13135  *
13136  *    Function : procUeRecfgCellInfo
13137  *
13138  *    Functionality: builds Mac Cell Cfg
13139  *
13140  * @params[in] DuMacUeCfg *macUeCfgToSend = Used to Store the information which
13141  *                       needs to send in other layer, as well as this can be
13142  *                       the variable which stores the information in DuCb.
13143  *             DuMacUeCfg *storedMacUeCfg = Null in case of sending the
13144  *                       information to other layer else it will have copyOfmacUeCfg
13145  *                       which we have stored in F1UeContextSetupDb
13146  *             void *cellInfo = CellGroupConfigRrc_t information which is send
13147  *                        by CU, which we have stored in F1UeContextSetupDb
13148  *
13149  * @return void
13150  *
13151  * ****************************************************************/
13152 uint8_t procUeRecfgCellInfo(DuMacUeCfg *macUeCfgToSend, DuMacUeCfg *storedMacUeCfg, void *cellInfo)
13153 {
13154    uint8_t ret = ROK;
13155    CellGroupConfigRrc_t *cellGrp = NULLP;
13156
13157    if(cellInfo)
13158    {
13159       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
13160       ret = extractUeRecfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
13161       if(ret == RFAILED)
13162          DU_LOG("\nERROR  -->  F1AP : Failed at procUeRecfgCellInfo()");
13163    }
13164    if(ret == RFAILED)
13165    {
13166       freeUeRecfgCellGrpInfo(macUeCfgToSend);
13167    }
13168    return ret;
13169 }
13170
13171 /*******************************************************************
13172  *
13173  * @brief Filling modulation info in mac ue cfg
13174  *
13175  * @details
13176  *
13177  *    Function : duFillModulationDetails
13178  *
13179  *    Functionality: Filling modulation info in mac ue cfg
13180  *
13181  * @params[in] MAC UE Config to be updated
13182  *             Current UE configuration
13183  *             UE NR capability from CU
13184  * @return ROK     - success
13185  *         RFAILED - failure
13186  *
13187  * ****************************************************************/
13188 void duFillModulationDetails(DuMacUeCfg *ueCfg, DuMacUeCfg *oldUeCfg, void *ueCap)
13189 {
13190    UE_NR_Capability_t *ueNrCap=NULLP;
13191
13192    if(!ueCap && oldUeCfg)
13193    {
13194       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
13195       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
13196    }
13197    else
13198    {
13199       ueNrCap = (UE_NR_Capability_t *)ueCap;
13200
13201       /* Filling DL modulation info */
13202       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
13203          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
13204          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
13205       {
13206          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
13207          {
13208             case ModulationOrder_qpsk:
13209                {
13210                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
13211                   break;
13212                }
13213             case ModulationOrder_qam16:
13214                {
13215                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
13216                   break;
13217                }
13218             case ModulationOrder_qam64:
13219                {
13220                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
13221                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
13222                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
13223                   break;
13224                }
13225             case ModulationOrder_qam256:
13226                {
13227                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
13228                   break;
13229                }
13230             default:
13231                {
13232                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
13233                   if(oldUeCfg)
13234                      memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
13235                   break;
13236                }
13237          }
13238       }
13239       else
13240       {
13241          if(oldUeCfg)
13242             memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
13243       }
13244
13245       /* Filling UL modulation info */
13246       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
13247          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
13248          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
13249       {
13250          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
13251          {
13252             case ModulationOrder_qpsk:
13253                {
13254                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
13255                   break;
13256                }
13257             case ModulationOrder_qam16:
13258                {
13259                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
13260                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
13261                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
13262                   break;
13263                }
13264             case ModulationOrder_qam64:
13265                {
13266                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
13267                   break;
13268                }
13269             case ModulationOrder_qam256:
13270                {
13271                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
13272                   break;
13273                }
13274             default:
13275                {
13276                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
13277                   if(oldUeCfg)
13278                      memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
13279                   break;
13280                }
13281          }
13282       }
13283       else
13284       {
13285          if(oldUeCfg)
13286             memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
13287       }
13288    }
13289 }
13290
13291 /*******************************************************************
13292  *
13293  * @brief Function to extract info from CU to DU RRC container extension
13294  *
13295  * @details
13296  *
13297  *    Function : extractCuToDuRrcInfoExt
13298  *
13299  *    Functionality: Function to extract info from CU to DU RRC container
13300  *    extension
13301  *
13302  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
13303  *
13304  * @return ROK
13305  *         RFAILED
13306  *
13307  * ****************************************************************/
13308 uint8_t extractCuToDuRrcInfoExt(ProtocolExtensionContainer_4624P16_t *protocolIeExtn, DuUeCfg *ueCfgDb)
13309 {
13310    uint8_t ieIdx =0;
13311    uint16_t recvBufLen =0;
13312    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
13313    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
13314    asn_dec_rval_t rval; /* Decoder return value */
13315    memset(&rval, 0, sizeof(asn_dec_rval_t));
13316
13317    if(protocolIeExtn)
13318    {
13319       for(ieIdx = 0; ieIdx < protocolIeExtn->list.count; ieIdx++)
13320       {
13321          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[ieIdx]));
13322          switch(extIeInfo->id)
13323          {
13324             case ProtocolIE_ID_id_CellGroupConfig:
13325                {
13326                   /* decoding the CellGroup Buf received */
13327                   recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
13328                   DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
13329                   if(cellGrpCfg)
13330                   {
13331                      memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
13332                      rval = uper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
13333                            extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
13334                      if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13335                      {
13336                         DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13337                         return RFAILED;
13338                      }
13339                      xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
13340
13341                      if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
13342                         return NULLP;
13343                      ueCfgDb->cellGrpCfg = cellGrpCfg;
13344                   }
13345                   break;
13346                }
13347
13348             case ProtocolIE_ID_id_HandoverPreparationInformation:
13349                {
13350                   DU_LOG("\nINFO -->  F1AP : Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
13351                   break;
13352                }
13353
13354             default:
13355                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation: %ld at decodeCellGrpCfg()", extIeInfo->id);
13356                break;
13357          }
13358       }
13359    }
13360    return ROK;
13361 }
13362
13363 /*******************************************************************
13364  *
13365  * @brief Fills Srb List received by CU
13366  *
13367  * @details
13368  *
13369  *    Function : procSrbListToSetup
13370  *
13371  *    Functionality: Fills Srb List received  by CU
13372  *
13373  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
13374  *             DuLcCfg pointer
13375  *             RlcBearerCfg pointer
13376  * @return void
13377  *
13378  * ****************************************************************/
13379 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, DuLcCfg *duMacLcToAdd, DuRlcBearerCfg *rlcLcToAdd)
13380 {
13381
13382    /* Filling RLC INFO */
13383    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
13384
13385    /* Filling MAC INFO */
13386    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, duMacLcToAdd, NULL)  != ROK)
13387    {
13388       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
13389       return RFAILED;
13390    }
13391
13392    return ROK;
13393 }
13394
13395
13396
13397 /*******************************************************************
13398  *
13399  * @brief extract Srb List received by CU
13400  *
13401  * @details
13402  *
13403  *    Function : extractSrbListToSetup
13404  *
13405  *    Functionality: extract Srb List received by CU
13406  *                   for both MAC and RLC
13407  *
13408  * @params[in] SRBs_ToBeSetup_Item_t pointer
13409  *             DuUeCfg pointer
13410  * @return ROK/RFAIED
13411  *
13412  * ****************************************************************/
13413
13414 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
13415 {
13416    uint8_t ret = ROK, srbIdx = 0, rlcLcIdx = 0;
13417    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
13418    DuLcCfg *macLcCtxt = NULLP;
13419    DuRlcBearerCfg *rlcLcCtxt = NULLP;
13420
13421    if(srbCfg)
13422    {
13423       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
13424       {
13425          macLcCtxt = NULL;
13426          rlcLcCtxt = NULL;
13427
13428          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
13429          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
13430          {
13431             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
13432             ret = RFAILED;
13433             break;
13434          }
13435          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
13436          {
13437             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
13438             ret = RFAILED;
13439             break;
13440          }
13441
13442          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numMacLcs; rlcLcIdx++)
13443          {
13444             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rlcBearerCfg.rbId == srbItem->sRBID && ueCfgDb->rlcLcCfg[rlcLcIdx].rlcBearerCfg.rbType == RB_TYPE_SRB)
13445             {
13446                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13447                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13448                break;
13449             }
13450          }
13451          if(!macLcCtxt)
13452          {
13453             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(DuLcCfg));
13454             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13455             ueCfgDb->numMacLcs++;
13456          }
13457          if(!rlcLcCtxt)
13458          {
13459             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(DuRlcBearerCfg));
13460             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13461             ueCfgDb->numRlcLcs++;
13462          }
13463
13464          ret = procSrbListToSetup(srbItem, macLcCtxt, rlcLcCtxt);
13465
13466          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13467                srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13468          if(ret == RFAILED)
13469          {
13470             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
13471             break;
13472          }
13473       }
13474    }
13475    else
13476       ret = RFAILED;
13477
13478    return ret;
13479 }
13480
13481 /*******************************************************************
13482  *
13483  * @brief Fills Drb List received by CU
13484  *
13485  * @details
13486  *
13487  *    Function : procDrbListToSetupMod
13488  *
13489  *    Functionality: Fills Drb List received by CU
13490  *                   for both MAC and RLC
13491  *
13492  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
13493  *             DRBs_ToBeModified_Item_t , lcId, DuLcCfg pointer,
13494  *             RlcBearerCfg , UpTnlCfg, DuRlcUeCfg
13495  * @return void
13496  *
13497  * ****************************************************************/
13498
13499 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
13500 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, DuLcCfg *macLcToAdd, DuRlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, DuRlcUeCfg *storedRlcUeCfg)
13501 {
13502    uint8_t cfgIdx = 0;
13503    RlcMode rlcModeInfo;
13504
13505    if(drbItem != NULLP)
13506    {
13507       /* Filling RLC INFO */
13508       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
13509       qoSInformation);
13510
13511       /* Filling MAC INFO */
13512       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
13513       {
13514          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13515          return RFAILED;
13516       }
13517    }
13518    else if(drbSetupModItem != NULLP)
13519    {
13520       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
13521       &drbSetupModItem->qoSInformation);
13522
13523       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
13524       {
13525          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13526          return RFAILED;
13527       }
13528    }
13529    else if(drbModItem != NULLP)
13530    {
13531       /* Drb to Mod IEs doesnot have rlcMode to be modified
13532        * in ASN. Hence no change in RLC configurations */
13533       if(storedRlcUeCfg != NULLP)
13534       {
13535          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
13536          {
13537             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcBearerCfg.lcId == lcId)
13538             {
13539                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcBearerCfg.rlcMode;
13540                break;
13541             }
13542          }
13543       }
13544
13545       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
13546       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
13547       {
13548          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13549          return RFAILED;
13550       }
13551    }
13552    return ROK;
13553 }
13554
13555 /*******************************************************************
13556  *
13557  * @brief extract Drb List received by CU
13558  *
13559  * @details
13560  *
13561  *    Function : extractDrbListToSetupMod
13562  *
13563  *    Functionality: extract Drb List received by CU
13564  *                   for both MAC and RLC
13565  *
13566  * @params[in] DRBs_ToBeSetup_Item_t pointer
13567  *             DuUeCfg pointer
13568  * @return ROK/RFAIED
13569  *
13570  * ****************************************************************/
13571
13572 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
13573  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, DuRlcUeCfg *rlcUeCfg)
13574 {
13575    uint8_t ret = ROK;
13576    uint8_t drbIdx = 0, rlcLcIdx = 0;
13577    uint8_t drbId = 0, lcId = 0;
13578    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
13579    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
13580    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
13581    DuLcCfg *macLcCtxt = NULLP;
13582    DuRlcBearerCfg *rlcLcCtxt = NULLP;
13583
13584    ret = ROK;
13585    if(drbCount > 0)
13586    {
13587       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
13588       {
13589          macLcCtxt = NULL;
13590          rlcLcCtxt = NULL;
13591
13592          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
13593          {
13594             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
13595             ret = RFAILED;
13596             break;
13597          }
13598          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
13599          {
13600             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
13601             ret = RFAILED;
13602             break;
13603          }
13604
13605          if(drbModCfg != NULLP)
13606          {
13607             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
13608             drbId = drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID;
13609          }
13610          else if(drbCfg != NULLP)
13611             drbId = drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item.dRBID;
13612          else if(drbSetupModCfg != NULL)
13613          {
13614             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
13615             drbId = drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item.dRBID;
13616          }
13617
13618          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numRlcLcs; rlcLcIdx++)
13619          {
13620             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rlcBearerCfg.rbId == drbId && \
13621                    ueCfgDb->rlcLcCfg[rlcLcIdx].rlcBearerCfg.rbType == RB_TYPE_DRB)
13622             {
13623                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13624                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13625                break;
13626             }
13627          }
13628          if(!macLcCtxt)
13629          {
13630             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(DuLcCfg));
13631             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13632             ueCfgDb->numMacLcs++;
13633          }
13634          if(!rlcLcCtxt)
13635          {
13636             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
13637             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13638             ueCfgDb->numRlcLcs++;
13639          }
13640
13641          if(drbModCfg != NULLP)
13642          {
13643             lcId = fetchLcId(drbId);
13644             if(lcId < MIN_DRB_LCID)
13645             {
13646                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
13647                break;
13648             }
13649             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
13650             macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13651             if(ret == RFAILED)
13652             {
13653                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
13654                break;
13655             }
13656             ueCfgDb->numDrbModified++;
13657          }
13658          else
13659          {
13660             lcId = getDrbLcId(drbBitMap);
13661             if(lcId == RFAILED)
13662             {
13663                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
13664                ret = RFAILED;
13665                break;
13666             }
13667             if(drbCfg != NULL)
13668             {
13669                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
13670                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13671                if(ret == RFAILED)
13672                {
13673                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
13674                   break;
13675                }
13676             }
13677             else if(drbSetupModCfg != NULL)
13678             {
13679                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
13680                      macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13681                if(ret == RFAILED)
13682                {
13683                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
13684                   break;
13685                }
13686                ueCfgDb->numDrbSetupMod++;
13687             }
13688          }
13689          ueCfgDb->numDrb++;
13690
13691          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13692                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13693          if(ret == RFAILED)
13694          {
13695             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
13696             break;
13697          }
13698       }
13699    }
13700    else
13701       ret = RFAILED;
13702
13703    return ret;
13704 }
13705
13706 /*******************************************************************
13707  *
13708  * @brief extract Drb List received from CU
13709  *
13710  * @details
13711  *
13712  *    Function : extractDrbListToRelease
13713  *
13714  *    Functionality: extract Drb List received from CU
13715  *                   for both MAC and RLC
13716  *
13717  * @params[in] DRBs_ToBeReleased_Item_t pointer
13718  *             DuUeCfg pointer
13719  * @return ROK/RFAIED
13720  *
13721  * ****************************************************************/
13722
13723 uint8_t extractDrbListToRelease(uint8_t ueId, DRBs_ToBeReleased_List_t *drbToRel, uint8_t drbCount, DuUeCfg *ueCfgDb, DuRlcUeCfg *rlcUeCfg)
13724 {
13725    uint8_t ret = ROK, teIdx = 0;
13726    uint8_t drbIdx = 0, rlcLcIdx = 0;
13727    uint8_t drbId = 0, lcId = 0;
13728    DRBs_ToBeReleased_ItemIEs_t *drbRelItem = NULLP;
13729    DuLcCfg *macLcCtxt = NULLP;
13730    DuRlcBearerCfg *rlcLcCtxt = NULLP;
13731
13732    ret = ROK;
13733    if(drbCount > 0)
13734    {
13735       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
13736       {
13737          macLcCtxt = NULL;
13738          rlcLcCtxt = NULL;
13739
13740          if(drbToRel != NULLP)
13741          {
13742             drbRelItem = (DRBs_ToBeReleased_ItemIEs_t *) drbToRel->list.array[drbIdx];
13743             drbId = drbRelItem->value.choice.DRBs_ToBeReleased_Item.dRBID;
13744          }
13745          else
13746          {
13747             DU_LOG("ERROR  --> DU APP : DrbToRelease pointer is NULL in extractDrbListToRelease");
13748             return RFAILED;
13749          }
13750
13751          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numRlcLcs; rlcLcIdx++)
13752          {
13753             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rlcBearerCfg.rbId == drbId && ueCfgDb->rlcLcCfg[rlcLcIdx].rlcBearerCfg.rbType == RB_TYPE_DRB)
13754             {
13755                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13756                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13757                break;
13758             }
13759          }
13760
13761          if(!macLcCtxt)
13762          {
13763             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(DuLcCfg));
13764             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13765             ueCfgDb->numMacLcs++;
13766          }
13767          if(!rlcLcCtxt)
13768          {
13769             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(DuRlcBearerCfg));
13770             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13771             ueCfgDb->numRlcLcs++;
13772          }
13773          lcId = fetchLcId(drbId);
13774          if(lcId < MIN_DRB_LCID)
13775          {
13776             DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToRelease() for Modified List", lcId);
13777             break;
13778          }
13779
13780          /* Filling RLC INFO */
13781          procRlcLcCfg(drbId, lcId, RB_TYPE_DRB, rlcLcCtxt->rlcBearerCfg.rlcMode, CONFIG_DEL, NULL, rlcLcCtxt, NULLP);
13782          /* Filling MAC INFO */
13783          if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_DEL, NULL, NULL, NULL, NULL, macLcCtxt, NULLP) != ROK)
13784          {
13785             DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in extractDrbListToRelease()");
13786             return RFAILED;
13787          }
13788          ueCfgDb->upTnlInfo[ueCfgDb->numDrb].configType = CONFIG_DEL;
13789          ueCfgDb->upTnlInfo[ueCfgDb->numDrb].drbId = drbId;
13790          ueCfgDb->upTnlInfo[ueCfgDb->numDrb].ueId = ueId;
13791
13792          for(teIdx = 0; teIdx < duCb.numTeId; teIdx++)
13793          {
13794             if((duCb.upTnlCfg[teIdx]->ueId == ueCfgDb->upTnlInfo[ueCfgDb->numDrb].ueId) && \
13795                   (duCb.upTnlCfg[teIdx]->drbId == ueCfgDb->upTnlInfo[ueCfgDb->numDrb].drbId))
13796             {
13797                DU_ALLOC(ueCfgDb->upTnlInfo[ueCfgDb->numDrb].tnlCfg1, sizeof(GtpTnlCfg));
13798                memcpy(ueCfgDb->upTnlInfo[ueCfgDb->numDrb].tnlCfg1, duCb.upTnlCfg[teIdx]->tnlCfg1, sizeof(GtpTnlCfg));
13799                break;
13800             }
13801          }
13802
13803          ueCfgDb->numDrb++;
13804          if(ret == RFAILED)
13805          {
13806             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToRelease() for Modified List");
13807             break;
13808          }
13809
13810          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToRelease():lcId:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13811                lcId,ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13812       }
13813    }
13814    else
13815       ret = RFAILED;
13816
13817    return ret;
13818 }
13819
13820 /*******************************************************************
13821  *
13822  * @brief Function to extract Dl RRC Msg received from CU
13823  *
13824  * @details
13825  *
13826  *    Function : extractDlRrcMsg
13827  *
13828  *    Functionality: Function to extract Dl RRC Msg received from CU
13829  *
13830  * @params[in] F1AP message
13831  * @return ROK     - success
13832  *         RFAILED - failure
13833  *
13834  * ****************************************************************/
13835
13836 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
13837    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
13838 {
13839    uint8_t ret = ROK;
13840    dlRrcMsg->rrcMsgSize = rrcContainer->size;
13841    if(dlRrcMsg->rrcMsgSize > 0)
13842    {
13843       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
13844       if(!dlRrcMsg->rrcMsgPdu)
13845       {
13846          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
13847          ret = RFAILED;
13848       }
13849       else
13850       {
13851          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
13852          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
13853          dlRrcMsg->srbId = SRB1_LCID;
13854          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
13855       }
13856    }
13857    return ret;
13858 }
13859
13860 /*******************************************************************
13861  *
13862  * @brief Extract UE capability info
13863  *
13864  * @details
13865  *
13866  *    Function : extractUeCapability
13867  *
13868  *    Functionality: Extract UE capability info and stores in ue Cb
13869  *
13870  * @params[in] Octet string of UE capability RAT container list
13871  * @return ROK     - success
13872  *         RFAILED - failure
13873  *
13874  * ****************************************************************/
13875 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
13876 {
13877    uint8_t  idx;
13878    uint16_t recvBufLen;
13879    asn_dec_rval_t rval;
13880    UE_NR_Capability_t  *ueNrCap = NULLP;
13881    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
13882
13883    /* Decoding UE Capability RAT Container List */
13884    recvBufLen = ueCapablityListBuf->size;
13885    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13886    if(!ueCapRatContList)
13887    {
13888       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
13889       return NULLP;
13890    }
13891    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13892    memset(&rval, 0, sizeof(asn_dec_rval_t));
13893    rval = uper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
13894           ueCapablityListBuf->buf, recvBufLen, 0, 0);
13895    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13896    {
13897       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13898       return NULLP;
13899    }
13900    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
13901
13902    /* Free encoded buffer after decoding */
13903
13904    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
13905    {
13906       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
13907       {
13908          /* Decoding UE NR Capability */
13909           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
13910           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
13911           if(!ueNrCap)
13912           {
13913              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
13914              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13915              return NULLP;
13916           }
13917           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
13918           memset(&rval, 0, sizeof(asn_dec_rval_t));
13919           rval = uper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
13920                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
13921           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13922           {
13923              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13924              return NULLP;
13925           }
13926           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
13927
13928           /* Free encoded buffer after decoding */
13929           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
13930       }
13931       free(ueCapRatContList->list.array[idx]);
13932    }
13933
13934    /* Free Memory*/
13935    free(ueCapRatContList->list.array);
13936    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13937    return ueNrCap;
13938 }
13939
13940 /*******************************************************************
13941 *
13942 * @brief free UE context setup request from CU
13943 *
13944 * @details
13945 *
13946 *    Function : freeAperDecodeF1UeContextSetupReq
13947 *
13948 *    Functionality: freeing part for the memory allocated by aper_decoder
13949 *
13950 * @params[in] F1AP message
13951 * @return ROK     - success
13952 *         RFAILED - failure
13953 *
13954 * ****************************************************************/
13955 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
13956 {
13957    uint8_t ieIdx = 0;
13958
13959    if(ueSetReq->protocolIEs.list.array != NULLP)
13960    {
13961       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
13962       {
13963          if(ueSetReq->protocolIEs.list.array[ieIdx])
13964          {
13965             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13966             {
13967                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13968                   break;
13969                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13970                   break;
13971                case ProtocolIE_ID_id_SpCell_ID:
13972                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
13973                   break;
13974                case ProtocolIE_ID_id_ServCellIndex:
13975                   break;
13976                case ProtocolIE_ID_id_SpCellULConfigured:
13977                   break;
13978                case ProtocolIE_ID_id_CUtoDURRCInformation:
13979
13980                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
13981                   break;
13982                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
13983
13984                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
13985                   break;
13986                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13987
13988                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
13989                   break;
13990                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13991
13992                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
13993                   break;
13994                case ProtocolIE_ID_id_RRCContainer:
13995                   {
13996
13997                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
13998                      {
13999
14000                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
14001                      }
14002                      break;
14003                   }
14004                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
14005                   break;
14006                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
14007                   {
14008                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
14009                      {
14010                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
14011                      }
14012                      break;
14013                   }
14014 #ifdef NR_DRX
14015                case ProtocolIE_ID_id_DRXCycle:
14016                   {
14017                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleLength)
14018                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleLength);
14019                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleTimer)
14020                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleTimer);
14021                      break;
14022                   }
14023 #endif
14024                 default:
14025                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
14026             }
14027             free(ueSetReq->protocolIEs.list.array[ieIdx]);
14028          }
14029       }
14030       free(ueSetReq->protocolIEs.list.array);
14031    }
14032 }
14033 /*******************************************************************
14034  *
14035  * @brief Process UE context setup request from CU
14036  *
14037  * @details
14038  *
14039  *    Function : procF1UeContextSetupReq
14040  *
14041  *    Functionality: Process UE context setup request from CU
14042  *
14043  * @params[in] F1AP message
14044  * @return ROK     - success
14045  *         RFAILED - failure
14046  *
14047  * ****************************************************************/
14048 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
14049 {
14050    int8_t ueIdx = -1;
14051    uint8_t  ret=0, ieIdx=0, ieExtIdx = 0;
14052    //uint8_t servCellIdx = 0;
14053    bool ueCbFound = false, hoInProgress = false;
14054    uint16_t cellIdx=0;
14055    uint64_t nrCellId = 0;
14056    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
14057    DuUeCb   *duUeCb = NULL;
14058    UEContextSetupRequest_t   *ueSetReq = NULL;
14059    DRBs_ToBeSetup_List_t *drbCfg = NULL;
14060    CUtoDURRCInformation_t *rrcInfo = NULL;
14061 #ifdef NR_DRX
14062    DRXCycle_t *drxCycle;
14063 #endif
14064    ret = ROK;
14065
14066    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
14067    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
14068    {
14069       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
14070       {
14071          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14072             {
14073                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
14074                break;
14075             }
14076
14077          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14078             {
14079                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
14080                break;
14081             }
14082
14083          case ProtocolIE_ID_id_SpCell_ID:
14084             {
14085                bitStringToInt(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
14086
14087                GET_CELL_IDX(nrCellId, cellIdx);
14088                if(!duCb.actvCellLst[cellIdx])
14089                {
14090                   DU_LOG("\nERROR  -->  F1AP : Cell Id [%lu] not found", nrCellId);
14091                   ret = RFAILED;
14092                }
14093                break;
14094             }
14095
14096          case ProtocolIE_ID_id_ServCellIndex:
14097             {
14098                //servCellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
14099                break;
14100             }
14101
14102          case ProtocolIE_ID_id_SpCellULConfigured:
14103             {
14104                /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
14105                   UL, SUL or UL+SUL for the indicated cell for the UE */
14106                break;
14107             }
14108
14109          case ProtocolIE_ID_id_CUtoDURRCInformation:
14110             {
14111                rrcInfo = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation;
14112
14113                /* Search if UE context is present */
14114                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
14115                {
14116                   if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId)
14117                   {
14118                      ueCbFound = true;
14119                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
14120                      break;
14121                   }
14122                }
14123
14124                /* Check if UE Handover scenario */
14125                if(rrcInfo->iE_Extensions)
14126                {
14127                   for(ieExtIdx = 0; ieExtIdx < rrcInfo->iE_Extensions->list.count; ieExtIdx++)
14128                   {
14129                      if(rrcInfo->iE_Extensions->list.array[ieExtIdx]->id == ProtocolIE_ID_id_HandoverPreparationInformation)
14130                      {
14131                         hoInProgress = true;
14132                         break;
14133                      }
14134                   }
14135                }
14136
14137                /* If UE context is not present, but UE is in handover */
14138                if(!ueCbFound && hoInProgress)
14139                {
14140                   ueIdx = getFreeBitFromUeBitMap(nrCellId);
14141                   if(ueIdx != -1)
14142                      gnbDuUeF1apId = ueIdx +1;
14143                   else
14144                   {
14145                      DU_LOG("\nERROR  -->  F1AP : No free UE IDX found in UE bit map of cell Id [%lu]", nrCellId);
14146                      ret = RFAILED;
14147                      break;
14148                   }
14149                   duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
14150                   duUeCb->f1UeDb = NULL;
14151                   duUeCb->gnbCuUeF1apId = gnbCuUeF1apId;
14152                   duUeCb->gnbDuUeF1apId = gnbDuUeF1apId;
14153                   GET_CRNTI(duUeCb->crnti, duUeCb->gnbDuUeF1apId);
14154                   duUeCb->ueState = UE_HANDIN_IN_PROGRESS;
14155                }
14156
14157                if(duUeCb)
14158                {
14159                   DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
14160                   if(duUeCb->f1UeDb)
14161                   {
14162                      memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
14163                      duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
14164                      duUeCb->f1UeDb->cellIdx = cellIdx;
14165                   }
14166                   else
14167                   {
14168                      DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
14169                      ret = RFAILED;
14170                      break;
14171                   }
14172                }
14173                else
14174                {
14175                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
14176                   ret = RFAILED;
14177                   break;
14178                }
14179
14180                /* Extract UE capability info */
14181                if(rrcInfo->uE_CapabilityRAT_ContainerList)
14182                {
14183                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = extractUeCapability(rrcInfo->uE_CapabilityRAT_ContainerList, duUeCb);
14184                }
14185
14186                /* Extract IE extension */
14187                if(rrcInfo->iE_Extensions)
14188                {
14189                   if(extractCuToDuRrcInfoExt(rrcInfo->iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
14190                   {
14191                      DU_LOG("\nERROR  -->  F1AP: Failed to extract CU to DU RRC information extension IE");
14192                      //TODO: Update the failure cause in ue context Setup Response
14193                      ret = RFAILED;
14194                   }
14195                }
14196                break;
14197             }
14198
14199 #ifdef NR_DRX
14200          case ProtocolIE_ID_id_DRXCycle:
14201             {
14202                duUeCb->f1UeDb->duUeCfg.drxCyclePres = true;
14203                drxCycle = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle;
14204                duUeCb->f1UeDb->duUeCfg.drxCycle.drxLongCycleLength =  convertLongDrxCycleLengthEnumToValue(drxCycle->longDRXCycleLength);
14205                if(drxCycle->shortDRXCycleLength)
14206                {
14207                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCyclePres = true;
14208                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycle = \
14209                   convertShortDrxCycleLengthEnumToValue(*(drxCycle->shortDRXCycleLength));
14210                }
14211                if(drxCycle->shortDRXCycleTimer)
14212                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycleTimer = *(drxCycle->shortDRXCycleTimer);
14213
14214                break;
14215             }
14216
14217 #endif
14218          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
14219             {
14220                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
14221                         &duUeCb->f1UeDb->duUeCfg))
14222                {
14223                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
14224                   //TODO: Update the failure cause in ue context Setup Response
14225                   ret = RFAILED;
14226                }
14227                break;
14228             }
14229
14230          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
14231             {
14232                drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
14233
14234                if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
14235                {
14236                   DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
14237                   //TODO: Update the failure cause in ue context Setup Response
14238                   ret = RFAILED;
14239                }
14240                break;
14241             }
14242          case ProtocolIE_ID_id_RRCContainer:
14243             {
14244                /* Filling Dl RRC Msg Info */
14245                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
14246                if(!duUeCb->f1UeDb->dlRrcMsg)
14247                {
14248                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
14249                   ret = RFAILED;
14250                }
14251                else
14252                {
14253                   duUeCb->f1UeDb->dlRrcMsgPres = true;
14254                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
14255                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
14256                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
14257                }
14258                break;
14259             }
14260
14261          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
14262             {
14263                if(duUeCb->f1UeDb->dlRrcMsg)
14264                {
14265                   if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
14266                   {
14267                      duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
14268                   }
14269                   else
14270                   {
14271                      DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
14272                   }
14273                }
14274                break;
14275             }
14276
14277          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
14278             {
14279                /* MaximumBitRate Uplink */
14280                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
14281                if(bitRateSize > 0)
14282                {
14283                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
14284                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
14285                   {
14286                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
14287                      ret = RFAILED;
14288                   }
14289                   else
14290                   {
14291                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
14292                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
14293                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
14294                   }
14295                }
14296                else
14297                   ret = RFAILED;
14298                break;
14299             }
14300
14301          default:
14302             {
14303                break;
14304             }
14305       } /* End of switch */
14306
14307       /* In case of any failure in any IE */
14308       if(ret == RFAILED)
14309       {
14310          // BuildAndSendUeContextSetupRsp(cellId,ueId);
14311          DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
14312          break;
14313       }
14314    } /* End of for loop of IEs */
14315
14316    if(ret == ROK)
14317       ret = duProcUeContextSetupRequest(duUeCb);
14318
14319    freeAperDecodeF1UeContextSetupReq(ueSetReq);
14320    return ret;
14321
14322 }
14323 /*******************************************************************
14324  * @brief Free the memory allocated for Dl Tunnel Info
14325  *
14326  * @details
14327  *
14328  *    Function : freeDlTnlInfo
14329  *
14330  *    Functionality:
14331  *       Free the memory allocated for Dl Tunnel Info
14332  *
14333  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
14334  * @return void
14335  *
14336  * ****************************************************************/
14337
14338 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
14339 {
14340    uint8_t arrIdx = 0;
14341
14342    if(tnlInfo)
14343    {
14344       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
14345       {
14346          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
14347                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
14348          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
14349                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
14350          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
14351          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
14352       }
14353       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
14354    }
14355 }
14356
14357 /*******************************************************************
14358  * @brief Free the memory allocated for DRB setup List
14359  *
14360  * @details
14361  *
14362  *    Function : freeDrbSetupList
14363  *
14364  *    Functionality:
14365  *       Free the memory allocated for DRB setup list
14366  *
14367  * @params[in] DRBs_Setup_List_t *
14368  * @return void
14369  *
14370  * ****************************************************************/
14371 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
14372 {
14373    uint8_t arrIdx = 0;
14374    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
14375
14376    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
14377    {
14378       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
14379       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
14380       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
14381    }
14382    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
14383 }
14384
14385 /*******************************************************************
14386  * @brief Free the memory allocated for UE Setup response
14387  *
14388  * @details
14389  *
14390  *    Function : FreeUeContextSetupRsp
14391  *
14392  *    Functionality:
14393  *       Free the memory allocated for UE Setup response
14394  *
14395  * @params[in] F1AP PDU for UE setup response
14396  * @return ROK     - success
14397  *         RFAILED - failure
14398  *
14399  * ****************************************************************/
14400 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
14401 {
14402    uint8_t idx;
14403    UEContextSetupResponse_t *ueSetRsp = NULLP;
14404
14405    if(f1apMsg)
14406    {
14407       if(f1apMsg->choice.successfulOutcome)
14408       {
14409          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
14410                     UEContextSetupResponse;
14411          if(ueSetRsp->protocolIEs.list.array)
14412          {
14413             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
14414             {
14415                if(ueSetRsp->protocolIEs.list.array[idx])
14416                {
14417                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
14418                   {
14419                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14420                         break;
14421                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14422                         break;
14423                      case ProtocolIE_ID_id_C_RNTI:
14424                         break;
14425                      case ProtocolIE_ID_id_DUtoCURRCInformation:
14426                         {
14427                            CellGroupConfig_t *cellGrpCfg = NULLP;
14428                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
14429                                          DUtoCURRCInformation.cellGroupConfig;
14430                            if(cellGrpCfg->buf != NULLP)
14431                            {
14432                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
14433                               cellGrpCfg = NULLP;
14434                            }
14435                            break;
14436                         }
14437                      case ProtocolIE_ID_id_DRBs_Setup_List:
14438                         {
14439                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
14440                            break;
14441                         }
14442                      default:
14443                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
14444                               ueSetRsp->protocolIEs.list.array[idx]->id);
14445                         break;
14446                   }
14447                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
14448                         sizeof(UEContextSetupResponseIEs_t));
14449                }
14450             }
14451             DU_FREE(ueSetRsp->protocolIEs.list.array, \
14452                   ueSetRsp->protocolIEs.list.size);
14453          }
14454          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14455       }
14456       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14457    }
14458 }
14459
14460 /*******************************************************************
14461  *
14462  * @brief Builds Ue context Setup Rsp DU To CU Info
14463  *
14464  * @details
14465  *
14466  *    Function : EncodeUeCntxtDuToCuInfo
14467  *
14468  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
14469  *
14470  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
14471  *
14472  * @return ROK     - success
14473  *         RFAILED - failure
14474  *
14475  ******************************************************************/
14476
14477 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
14478 {
14479    asn_enc_rval_t        encRetVal;
14480
14481    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
14482    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
14483    encBufSize = 0;
14484    encRetVal = uper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
14485    /* Encode results */
14486    if(encRetVal.encoded == ENCODE_FAIL)
14487    {
14488       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
14489             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14490       return RFAILED;
14491    }
14492    else
14493    {
14494       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
14495 #ifdef DEBUG_ASN_PRINT
14496       for(int i=0; i< encBufSize; i++)
14497       {
14498          printf("%x",encBuf[i]);
14499       }
14500 #endif
14501    }
14502    duToCuCellGrp->size = encBufSize;
14503    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
14504    if(!duToCuCellGrp->buf)
14505    {
14506       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
14507    }
14508    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
14509    return ROK;
14510 }
14511
14512 /*******************************************************************
14513  *
14514  * @brief Fills Dl Gtp tunnel Info
14515  *
14516  * @details
14517  *
14518  *    Function : fillGtpTunnelforDl
14519  *
14520  *    Functionality: Fills Dl Gtp tunnel Info
14521  *
14522  * @params[in]
14523  *
14524  * @return ROK     - success
14525  *         RFAILED - failure
14526  *
14527  * ****************************************************************/
14528
14529 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
14530 {
14531    uint8_t bufSize = 0;
14532
14533    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
14534    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
14535    if(gtpDl->transportLayerAddress.buf == NULLP)
14536    {
14537       return RFAILED;
14538    }
14539    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
14540
14541    /*GTP TEID*/
14542    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
14543    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
14544    if(gtpDl->gTP_TEID.buf == NULLP)
14545    {
14546       return RFAILED;
14547    }
14548    bufSize = 3; /*forming an Octect String*/
14549    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
14550
14551    return ROK;
14552 }
14553
14554 /*******************************************************************
14555  *
14556  * @brief Fills DL Tunnel Setup List
14557  *
14558  * @details
14559  *
14560  *    Function : fillDlTnlSetupList
14561  *
14562  *    Functionality: Fills the DL Tunnel Setup List
14563  *
14564  * @params[in]
14565  *
14566  * @return ROK     - success
14567  *         RFAILED - failure
14568  *
14569  * ****************************************************************/
14570
14571 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
14572 {
14573    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14574
14575    eleCount = 1;
14576    dlTnlInfo->list.count = eleCount;
14577    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
14578
14579    /* Initialize the DL Tnl Setup List Members */
14580    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
14581    if(dlTnlInfo->list.array == NULLP)
14582    {
14583       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
14584       ret = RFAILED;
14585    }
14586    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14587    {
14588       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
14589       if(dlTnlInfo->list.array[arrIdx] == NULLP)
14590       {
14591          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
14592          return RFAILED;
14593       }
14594       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
14595       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
14596       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
14597       {
14598          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
14599          return RFAILED;
14600       }
14601       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
14602                tnlCfg->tnlCfg1);
14603       if(ret != ROK)
14604          break;
14605    }
14606    return ret;
14607 }
14608
14609 /*******************************************************************
14610  *
14611  * @brief Fills the Drb Setup List for Ue Context Setup Response
14612  *
14613  * @details
14614  *
14615  *    Function : fillDrbSetupList
14616  *
14617  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
14618  *
14619  * @params[in]
14620  *
14621  * @return ROK     - success
14622  *         RFAILED - failure
14623  *
14624  * ****************************************************************/
14625 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
14626 {
14627    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14628    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
14629
14630    eleCount = ueCfg->numDrb;
14631    drbSetupList->list.count = eleCount;
14632    drbSetupList->list.size = \
14633         (eleCount * sizeof(DRBs_Setup_Item_t *));
14634
14635    /* Initialize the Drb Setup List Members */
14636    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
14637    if(drbSetupList->list.array == NULLP)
14638    {
14639       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
14640       ret = RFAILED;
14641    }
14642
14643    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14644    {
14645       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
14646       if(drbSetupList->list.array[arrIdx] == NULLP)
14647       {
14648          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
14649          return RFAILED;
14650       }
14651       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
14652       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
14653       drbItemIe->criticality = Criticality_reject;
14654       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
14655       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
14656       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
14657           &ueCfg->upTnlInfo[arrIdx]);
14658       if(ret != ROK)
14659          break;
14660    }
14661    return ret;
14662 }
14663
14664 /*******************************************************************
14665  *
14666  * @brief Builds and sends the UE Setup Response
14667  *
14668  * @details
14669  *
14670  *    Function : BuildAndSendUeContextSetupRsp
14671  *
14672  *    Functionality: Constructs the UE Setup Response and sends
14673  *                   it to the DU through SCTP.
14674  *
14675  * @params[in] uint8_t cellId,uint8_t ueId
14676  *
14677  * @return ROK     - success
14678  *         RFAILED - failure
14679  *
14680  * ****************************************************************/
14681 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
14682 {
14683    uint8_t   idx, ret, cellIdx, elementCnt;
14684    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
14685    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
14686    asn_enc_rval_t  encRetVal;        /* Encoder return value */
14687    F1AP_PDU_t               *f1apMsg = NULLP;
14688    UEContextSetupResponse_t *ueSetRsp = NULLP;
14689    DuUeCb                   *ueCb = NULLP;
14690
14691    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
14692
14693    while(true)
14694    {
14695       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14696       if(f1apMsg == NULLP)
14697       {
14698          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14699          ret = RFAILED;
14700          break;
14701       }
14702
14703       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
14704       DU_ALLOC(f1apMsg->choice.successfulOutcome,
14705             sizeof(SuccessfulOutcome_t));
14706       if(f1apMsg->choice.successfulOutcome == NULLP)
14707       {
14708          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
14709          ret = RFAILED;
14710          break;
14711       }
14712
14713       f1apMsg->choice.successfulOutcome->procedureCode = \
14714                                                          ProcedureCode_id_UEContextSetup;
14715       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
14716       f1apMsg->choice.successfulOutcome->value.present = \
14717                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
14718
14719       ueSetRsp =
14720          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
14721       elementCnt = 5;
14722       ueSetRsp->protocolIEs.list.count = elementCnt;
14723       ueSetRsp->protocolIEs.list.size = \
14724                                         elementCnt * sizeof(UEContextSetupResponse_t *);
14725
14726       /* Initialize the UESetup members */
14727       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
14728             ueSetRsp->protocolIEs.list.size);
14729       if(ueSetRsp->protocolIEs.list.array == NULLP)
14730       {
14731          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14732          ret = RFAILED;
14733          break;
14734       }
14735
14736       for(idx=0; idx<elementCnt; idx++)
14737       {
14738          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
14739                sizeof(UEContextSetupResponseIEs_t));
14740          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
14741          {
14742             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14743             ret = RFAILED;
14744             break;
14745          }
14746       }
14747       /* Fetching Ue Cb Info*/
14748       GET_CELL_IDX(cellId, cellIdx);
14749       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
14750       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
14751       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
14752
14753       idx = 0;
14754       /*GNB CU UE F1AP ID*/
14755       ueSetRsp->protocolIEs.list.array[idx]->id = \
14756                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14757       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14758       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14759                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
14760       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14761
14762       /*GNB DU UE F1AP ID*/
14763       idx++;
14764       ueSetRsp->protocolIEs.list.array[idx]->id = \
14765                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14766       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14767       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14768                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
14769       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14770
14771
14772       /*DUtoCURRC Information */
14773       idx++;
14774       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14775                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
14776       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14777       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14778                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
14779       BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
14780
14781       /* CRNTI */
14782       idx++;
14783       ueSetRsp->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_C_RNTI;
14784       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14785       ueSetRsp->protocolIEs.list.array[idx]->value.present = UEContextSetupResponseIEs__value_PR_C_RNTI;
14786       ueSetRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI = ueCb->crnti;
14787
14788
14789       /* Drb Setup List */
14790       idx++;
14791       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14792                                                    ProtocolIE_ID_id_DRBs_Setup_List;
14793       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14794       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14795                                                             UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
14796       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
14797             &ueCb->f1UeDb->duUeCfg);
14798       if(ret == RFAILED)
14799       {
14800          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
14801          freeF1UeDb(ueCb->f1UeDb);
14802          ueCb->f1UeDb = NULLP;
14803          break;
14804       }
14805
14806       /* Free UeContext Db created during Ue context Req */
14807       freeF1UeDb(ueCb->f1UeDb);
14808       ueCb->f1UeDb = NULLP;
14809
14810       /* TODO: To send Drb list */
14811       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14812
14813       /* Encode the UE context setup response type as APER */
14814       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
14815       encBufSize = 0;
14816       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14817             encBuf);
14818       /* Encode results */
14819       if(encRetVal.encoded == ENCODE_FAIL)
14820       {
14821          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
14822                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14823          ret = RFAILED;
14824          break;
14825       }
14826       else
14827       {
14828          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
14829 #ifdef DEBUG_ASN_PRINT
14830          for(int i=0; i< encBufSize; i++)
14831          {
14832             printf("%x",encBuf[i]);
14833          }
14834 #endif
14835       }
14836
14837       /* Sending  msg  */
14838       if(sendF1APMsg()  != ROK)
14839       {
14840          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
14841          ret = RFAILED;
14842          break;
14843       }
14844       break;
14845    }
14846    FreeUeContextSetupRsp(f1apMsg);
14847    return ret;
14848 }/* End of BuildAndSendUeContextSetupRsp */
14849
14850 /*******************************************************************
14851 *
14852 * @brief  Build And Send Ue Context Rsp
14853 *
14854 * @details
14855 *
14856 *    Function : BuildAndSendUeCtxtRsp
14857 *
14858 *    Functionality : Build And Send Ue Context Rsp
14859
14860 * @params[in]
14861 * @return sucess = ROK
14862 *         failure = RFAILED
14863 *
14864 * ****************************************************************/
14865 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
14866 {
14867    uint8_t cellIdx = 0, actionType = 0;
14868
14869    GET_CELL_IDX(cellId, cellIdx);
14870    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
14871
14872    switch(actionType)
14873    {
14874       case UE_CTXT_SETUP:
14875          {
14876             if((BuildAndSendUeContextSetupRsp(cellId,ueId)) != ROK)
14877             {
14878                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextSetupRsp()");
14879                return RFAILED;
14880             }
14881             break;
14882          }
14883       case UE_CTXT_MOD:
14884          {
14885             if((BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1])) != ROK)
14886             {
14887                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextModRsp");
14888                return RFAILED;
14889             }
14890             break;
14891          }
14892       default:
14893          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
14894          break;
14895
14896    }
14897    return ROK;
14898 }
14899
14900 /*******************************************************************
14901  *
14902  * @brief deallocating the memory of  F1reset msg
14903  *
14904  * @details
14905  *
14906  *    Function : FreeF1ResetReq
14907  *
14908  *    Functionality :
14909  *         - freeing memory of F1reset request msg
14910  *
14911  * @params[in]
14912  * @return void
14913  *
14914  *
14915  * ****************************************************************/
14916 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
14917 {
14918    uint8_t idx =0 ;
14919    Reset_t *f1ResetMsg;
14920
14921    if(f1apMsg)
14922    {
14923       if(f1apMsg->choice.initiatingMessage)
14924       {
14925          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14926
14927          if(f1ResetMsg->protocolIEs.list.array)
14928          {
14929             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
14930             {
14931                if(f1ResetMsg->protocolIEs.list.array[idx])
14932                {
14933                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14934                }
14935             }
14936             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14937          }
14938          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14939       }
14940       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14941    }
14942 }
14943 /*******************************************************************
14944  *
14945  * @brief Build and Send F1reset request
14946  *
14947  * @details
14948  *
14949  *    Function : BuildAndSendF1ResetReq
14950  *
14951  *    Functionality:
14952  *         - Build and Send F1reset request msg
14953  *
14954  * @params[in]
14955  * @return ROK     - success
14956  *         RFAILED - failure
14957  *
14958  * ****************************************************************/
14959 uint8_t BuildAndSendF1ResetReq()
14960 {
14961    uint8_t          elementCnt=0;
14962    uint8_t          idx=0;
14963    uint8_t          ret= RFAILED;
14964    Reset_t          *f1ResetMsg = NULLP;
14965    F1AP_PDU_t       *f1apMsg = NULLP;
14966    asn_enc_rval_t   encRetVal;
14967    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
14968    do
14969    {
14970       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14971       if(f1apMsg == NULLP)
14972       {
14973          break;
14974       }
14975       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14976       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14977       if(f1apMsg->choice.initiatingMessage == NULLP)
14978       {
14979          break;
14980       }
14981       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
14982       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
14983       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
14984
14985       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14986
14987       elementCnt = 3;
14988       f1ResetMsg->protocolIEs.list.count = elementCnt;
14989       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
14990
14991       /* Initialize the F1Setup members */
14992       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14993       if(f1ResetMsg->protocolIEs.list.array == NULLP)
14994       {
14995          break;
14996       }
14997       for(idx=0; idx<elementCnt; idx++)
14998       {
14999          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
15000          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
15001          {
15002             break;
15003          }
15004       }
15005
15006       /*TransactionID*/
15007       idx=0;
15008       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
15009       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
15010       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
15011       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
15012
15013       /*Cause*/
15014       idx++;
15015       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
15016       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
15017       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
15018       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
15019       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
15020
15021       /*Reset Type*/
15022       idx++;
15023       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
15024       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
15025       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
15026       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
15027       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
15028
15029       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15030
15031       /* Encode the F1SetupRequest type as APER */
15032       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15033       encBufSize = 0;
15034       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
15035             encBuf);
15036
15037       /* Encode results */
15038       if(encRetVal.encoded == ENCODE_FAIL)
15039       {
15040          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
15041                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15042          break;
15043       }
15044       else
15045       {
15046          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
15047 #ifdef DEBUG_ASN_PRINT
15048          for(idx=0; idx< encBufSize; idx++)
15049          {
15050             printf("%x",encBuf[idx]);
15051          }
15052 #endif
15053       }
15054
15055       if(sendF1APMsg() != ROK)
15056       {
15057          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
15058          break;
15059       }
15060
15061       ret = ROK;
15062       break;
15063    }while(true);
15064
15065    FreeF1ResetReq(f1apMsg);
15066    return ret;
15067 }
15068 /*******************************************************************
15069  *
15070  * @brief Build And Send F1ResetAck
15071  *
15072  * @details
15073  *
15074  *    Function : BuildAndSendF1ResetAck
15075  *
15076  *    Functionality:
15077  *         - Build And Send  F1ResetRSP
15078  *
15079  * @return ROK     - success
15080  *         RFAILED - failure
15081  *
15082  * ****************************************************************/
15083 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
15084 {
15085    uint8_t idx;
15086    ResetAcknowledge_t *f1ResetAck;
15087
15088    if(f1apMsg)
15089    {
15090       if(f1apMsg->choice.successfulOutcome)
15091       {
15092          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
15093
15094          if(f1ResetAck->protocolIEs.list.array)
15095          {
15096             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
15097             {
15098                if(f1ResetAck->protocolIEs.list.array[idx])
15099                {
15100                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
15101                }
15102             }
15103             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
15104          }
15105          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15106       }
15107       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
15108    }
15109 }
15110
15111 /*******************************************************************
15112  *
15113  * @brief Build And Send F1ResetAck
15114  *
15115  * @details
15116  *
15117  *    Function : BuildAndSendF1ResetAck
15118  *
15119  *    Functionality:
15120  *         - Build And Send  F1ResetRSP
15121  *
15122  *  @params[in]
15123  * @return ROK     - success
15124  *         RFAILED - failure
15125  *
15126  * ****************************************************************/
15127 uint8_t BuildAndSendF1ResetAck()
15128 {
15129    uint8_t                idx = 0;
15130    uint8_t                elementCnt = 0;
15131    uint8_t                ret = RFAILED;
15132    F1AP_PDU_t             *f1apMsg = NULL;
15133    ResetAcknowledge_t     *f1ResetAck = NULLP;
15134    asn_enc_rval_t         encRetVal;
15135    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
15136
15137    do{
15138       /* Allocate the memory for F1ResetRequest_t */
15139       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
15140       if(f1apMsg == NULLP)
15141       {
15142          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
15143          break;
15144       }
15145
15146       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
15147
15148       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15149       if(f1apMsg->choice.successfulOutcome == NULLP)
15150       {
15151          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
15152          break;
15153       }
15154       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
15155       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
15156       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
15157
15158       elementCnt = 1;
15159
15160       f1ResetAck->protocolIEs.list.count = elementCnt;
15161       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
15162
15163       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
15164       if(f1ResetAck->protocolIEs.list.array == NULLP)
15165       {
15166          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
15167          break;
15168       }
15169
15170       for(idx=0; idx<elementCnt; idx++)
15171       {
15172          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
15173          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
15174          {
15175             break;
15176          }
15177       }
15178       /*TransactionID*/
15179       idx = 0;
15180       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
15181       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
15182       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
15183       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
15184
15185       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15186
15187       /* Encode the F1SetupRequest type as UPER */
15188       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15189       encBufSize = 0;
15190       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
15191
15192       /* Check encode results */
15193       if(encRetVal.encoded == ENCODE_FAIL)
15194       {
15195          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
15196                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15197          break;
15198       }
15199       else
15200       {
15201          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
15202 #ifdef DEBUG_ASN_PRINT
15203          for(int i=0; i< encBufSize; i++)
15204          {
15205             printf("%x",encBuf[i]);
15206          }
15207 #endif
15208       }
15209       /* Sending msg */
15210       if(sendF1APMsg() != ROK)
15211       {
15212          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
15213          break;
15214       }
15215
15216       ret = ROK;
15217       break;
15218    }while(true);
15219
15220    FreeF1ResetAck(f1apMsg);
15221    return ret;
15222 }
15223 /******************************************************************
15224 *
15225 * @brief free F1 reset msg allocated by aper_decoder
15226 *
15227 * @details
15228 *
15229 *    Function : freeAperDecodeF1ResetMsg
15230 *
15231 *    Functionality: free F1 reset msg allocated by aper_decoder
15232 *
15233 * @params[in] Reset_t *f1ResetMsg
15234 * @return void
15235 *
15236 * ****************************************************************/
15237
15238 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
15239 {
15240    uint8_t ieIdx =0;
15241    if(f1ResetMsg->protocolIEs.list.array)
15242    {
15243       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
15244       {
15245          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
15246          {
15247             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
15248          }
15249       }
15250       free(f1ResetMsg->protocolIEs.list.array);
15251    }
15252 }
15253
15254 /******************************************************************
15255  *
15256  * @brief Processes DL RRC Message Transfer  sent by CU
15257  *
15258  * @details
15259  *
15260  *    Function : procF1ResetReq
15261  *
15262  *    Functionality: Processes DL RRC Message Transfer sent by CU
15263  *
15264  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15265  * @return ROK     - success
15266  *         RFAILED - failure
15267  *
15268  * ****************************************************************/
15269 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
15270 {
15271    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
15272    uint8_t       ieIdx = 0;
15273    uint8_t        ret = ROK;
15274    Reset_t       *f1ResetMsg = NULLP;
15275
15276    DU_LOG("\nINFO   -->  Processing F1 reset request");
15277    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
15278
15279    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
15280    {
15281       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
15282       {
15283          case ProtocolIE_ID_id_TransactionID:
15284             break;
15285
15286          case ProtocolIE_ID_id_Cause:
15287             break;
15288
15289          case ProtocolIE_ID_id_ResetType:
15290             {
15291                break;
15292             }
15293
15294          default:
15295             break;
15296       }
15297    }
15298    ret = BuildAndSendF1ResetAck();
15299    DU_LOG("\nINFO   -->  UE release is not supported for now");
15300
15301    freeAperDecodeF1ResetMsg(f1ResetMsg);
15302
15303    return ret;
15304 }
15305
15306 /*******************************************************************
15307  *
15308  * @brief free the RRC delivery report
15309  *
15310  * @details
15311  *
15312  *    Function : freeRrcDeliveryReport
15313  *
15314  *    Functionality: free the RRC delivery report
15315  *
15316  * @params[in]
15317  * @return ROK     - success
15318  *         RFAILED - failure
15319  *
15320  * ****************************************************************/
15321 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
15322 {
15323    uint8_t idx=0;
15324    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
15325
15326    if(f1apMsg)
15327    {
15328       if(f1apMsg->choice.initiatingMessage)
15329       {
15330          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
15331          if(rrcDeliveryReport->protocolIEs.list.array)
15332          {
15333             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
15334                   idx++)
15335             {
15336                if(rrcDeliveryReport->protocolIEs.list.array[idx])
15337                {
15338                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
15339                         sizeof(RRCDeliveryReportIEs_t));
15340                }
15341             }
15342             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
15343                   rrcDeliveryReport->protocolIEs.list.size);
15344          }
15345          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
15346       }
15347       DU_FREE(f1apMsg,
15348             sizeof(F1AP_PDU_t));
15349    }
15350 }
15351
15352 /*******************************************************************
15353 *
15354 * @brief Builds and sends the RRC delivery report
15355 *
15356 * @details
15357 *
15358 *    Function : BuildAndSendRrcDeliveryReport
15359 *
15360 *    Functionality: Builds and sends the RRC delivery report
15361 *
15362 * @params[in]
15363 *
15364 * @return ROK     - success
15365 *         RFAILED - failure
15366 *
15367 * ****************************************************************/
15368 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
15369    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
15370 {
15371    uint8_t             ret = RFAILED;
15372    uint8_t             idx    = 0;
15373    uint8_t             idx1   = 0;
15374    uint8_t             elementCnt = 0;
15375    F1AP_PDU_t          *f1apMsg = NULLP;
15376    asn_enc_rval_t      encRetVal;
15377    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
15378
15379    do{
15380
15381       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
15382       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
15383       if(f1apMsg == NULLP)
15384       {
15385          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
15386          break;
15387       }
15388       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
15389       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
15390       if(f1apMsg->choice.initiatingMessage == NULLP)
15391       {
15392          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
15393          break;
15394       }
15395       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
15396       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
15397       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
15398
15399       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
15400       elementCnt = 4;
15401       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
15402       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
15403
15404       /* Initialize the F1Setup members */
15405       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
15406       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
15407       {
15408          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
15409          break;
15410       }
15411       for(idx =0 ;idx <elementCnt; idx++)
15412       {
15413          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
15414          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
15415          {
15416             break;
15417          }
15418       }
15419
15420       idx1 = 0;
15421
15422       /*GNB CU UE F1AP ID*/
15423       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
15424       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
15425       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
15426       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
15427
15428       /*GNB DU UE F1AP ID*/
15429       idx1++;
15430       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
15431       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
15432       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
15433       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
15434
15435       /*RRC delivery status*/
15436       idx1++;
15437       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
15438       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
15439       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
15440       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
15441       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
15442       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
15443       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
15444
15445       /* SRB ID */
15446       idx1++;
15447       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
15448       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
15449       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
15450       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
15451
15452       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15453
15454       /* Encode the RRC DELIVERY REPORT type as APER */
15455       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15456       encBufSize = 0;
15457       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
15458             encBuf);
15459
15460       /* Encode results */
15461       if(encRetVal.encoded == ENCODE_FAIL)
15462       {
15463          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
15464                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15465          break;
15466       }
15467       else
15468       {
15469          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
15470 #ifdef DEBUG_ASN_PRINT
15471          for(idx=0; idx< encBufSize; idx++)
15472          {
15473             printf("%x",encBuf[idx]);
15474          }
15475 #endif
15476       }
15477
15478       /* Sending msg */
15479       if(sendF1APMsg() != ROK)
15480       {
15481          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
15482          break;
15483       }
15484       ret = ROK;
15485       break;
15486
15487    }while(true);
15488
15489    freeRrcDeliveryReport(f1apMsg);
15490    return ret;
15491 }
15492
15493 /*******************************************************************
15494  *
15495  * @brief Processes cells to be activated
15496  *
15497  * @details
15498  *
15499  *    Function : extractCellsToBeActivated
15500  *
15501  *    Functionality:
15502  *      - Processes cells to be activated list received in F1SetupRsp
15503  *
15504  * @params[in] void
15505  * @return ROK     - success
15506  *         RFAILED - failure
15507  *
15508  * ****************************************************************/
15509
15510 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
15511 {
15512    uint8_t  ret = ROK;
15513    uint16_t idx, pci = 0;
15514    uint64_t nci;
15515    Cells_to_be_Activated_List_Item_t cell;
15516
15517    for(idx=0; idx<cellsToActivate.list.count; idx++)
15518    {
15519       nci = 0;
15520       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
15521       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
15522
15523       if(cell.nRPCI)
15524       {
15525          pci = *cell.nRPCI;
15526       }
15527       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
15528    }
15529    return ret;
15530 }
15531 /******************************************************************
15532 *
15533 * @brief Processes F1 Setup Response allocated by aper_decoder
15534 *
15535 * @details
15536 *
15537 *    Function : freeF1SetupRsp
15538 *
15539 *    Functionality: free F1 Setup Response allocated by aper_decoder
15540 *
15541 * @params[in] F1SetupResponse_t *f1SetRspMsg
15542 * @return void
15543 *
15544 * ****************************************************************/
15545
15546 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
15547 {
15548    uint8_t ieIdx =0;
15549    uint8_t arrIdx =0;
15550    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
15551    RRC_Version_t      *rrcVer =NULLP;
15552
15553    if(f1SetRspMsg->protocolIEs.list.array)
15554    {
15555       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
15556       {
15557          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
15558          {
15559             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
15560             {
15561                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15562                   {
15563                      cellToActivate =
15564                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
15565                      if(cellToActivate->list.array)
15566                      {
15567                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
15568                         {
15569                            if(cellToActivate->list.array[arrIdx])
15570                            {
15571
15572                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
15573                               pLMN_Identity.buf)
15574                               {
15575                                  if(cellToActivate->list.array[0]->value.choice.\
15576                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
15577                                  {
15578                                     free(cellToActivate->list.array[0]->value.choice.\
15579                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
15580                                  }
15581
15582                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
15583                                        nRCGI.pLMN_Identity.buf);
15584                               }
15585                               free(cellToActivate->list.array[arrIdx]);
15586                            }
15587                         }
15588                         free(cellToActivate->list.array);
15589                      }
15590                      break;
15591                   }
15592                case ProtocolIE_ID_id_TransactionID:
15593                   {
15594                      break;
15595                   }
15596                case ProtocolIE_ID_id_gNB_CU_Name:
15597                   {
15598                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
15599                      break;
15600                   }
15601                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15602                   {
15603                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
15604                      if(rrcVer->latest_RRC_Version.buf)
15605                      {
15606                         if(rrcVer->iE_Extensions)
15607                         {
15608                            if(rrcVer->iE_Extensions->list.array)
15609                            {
15610                               if(rrcVer->iE_Extensions->list.array[0])
15611                               {
15612                                  if(rrcVer->iE_Extensions->list.\
15613                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
15614                                  {
15615                                     free(rrcVer->iE_Extensions->list.\
15616                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
15617                                  }
15618                                  free(rrcVer->iE_Extensions->list.array[0]);
15619                               }
15620                               free(rrcVer->iE_Extensions->list.array);
15621                            }
15622                            free(rrcVer->iE_Extensions);
15623                         }
15624                         free(rrcVer->latest_RRC_Version.buf);
15625                      }
15626                      break;
15627
15628                   }
15629                default:
15630                   {
15631                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15632                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
15633                   }
15634             }
15635             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
15636          }
15637       }
15638       free(f1SetRspMsg->protocolIEs.list.array);
15639    }
15640 }
15641 /******************************************************************
15642  *
15643  * @brief Processes F1 Setup Response sent by CU
15644  *
15645  * @details
15646  *
15647  *    Function : procF1SetupRsp
15648  *
15649  *    Functionality: Processes F1 Setup Response sent by CU
15650  *
15651  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15652  * @return ROK     - success
15653  *         RFAILED - failure
15654  *
15655  * ****************************************************************/
15656 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
15657 {
15658    uint8_t ret = ROK;
15659    uint16_t idx =0;
15660    F1SetupResponse_t *f1SetRspMsg = NULLP;
15661    GNB_CU_Name_t     *cuName = NULLP;
15662    F1SetupRsp  f1SetRspDb;
15663    RRC_Version_t      *rrcVer =NULLP;
15664
15665    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
15666
15667    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
15668    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
15669
15670    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
15671    {
15672       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
15673       {
15674          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15675             {
15676                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
15677                      value.choice.Cells_to_be_Activated_List);
15678                break;
15679             }
15680          case ProtocolIE_ID_id_TransactionID:
15681             {
15682                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
15683                                     value.choice.TransactionID;
15684                break;
15685             }
15686          case ProtocolIE_ID_id_gNB_CU_Name:
15687             {
15688                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
15689                         value.choice.GNB_CU_Name;
15690                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
15691                break;
15692             }
15693          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15694             {
15695                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
15696                strcpy(f1SetRspDb.rrcVersion.rrcVer,
15697                      (const char*)rrcVer->latest_RRC_Version.buf);
15698                break;
15699             }
15700          default:
15701             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15702                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
15703       }
15704    }
15705
15706    duProcF1SetupRsp();
15707    freeAperDecodeF1SetupRsp(f1SetRspMsg);
15708
15709    if(fillE2NodeComponentRspInfo(F1, duCfgParam.duId, E2_NODE_COMPONENT_ADD, recvBufLen, recvBuf) !=ROK)
15710    {
15711       DU_LOG("\nERROR  -->  F1AP : Failed to add the e2 node in the list");
15712       return RFAILED;
15713    }
15714
15715    if(BuildAndSendE2SetupReq() != ROK)
15716    {
15717       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
15718       return RFAILED;
15719    }
15720    return ret;
15721 }
15722 /*******************************************************************
15723 *
15724 * @brief free GNB DU config update ack
15725 *
15726 * @details
15727 *
15728 *    Function : freeAperDecodeGnbDuAck
15729 *
15730 *    Functionality: Processes GNB DU config update ack And
15731 *                     added free part for the memory allocated by aper_decoder
15732 *
15733 * @params[in] F1AP_PDU_t ASN decoded F1AP message
15734 * @return ROK     - success
15735 *         RFAILED - failure
15736 *
15737 * ****************************************************************/
15738
15739 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
15740 {
15741    uint8_t ieIdx = 0;
15742
15743    if(gnbDuAck->protocolIEs.list.array)
15744    {
15745       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15746       {
15747          if(gnbDuAck->protocolIEs.list.array[ieIdx])
15748          {
15749             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
15750          }
15751       }
15752       free(gnbDuAck->protocolIEs.list.array);
15753    }
15754 }
15755
15756 /*******************************************************************
15757 *
15758 * @brief Building  result of gnb-du config update ack output
15759 *
15760 * @details
15761 *
15762 *    Function : duProcGnbDuCfgUpdAckMsg
15763 *
15764 *    Functionality:
15765 *        Building output of gnb-du config update ack
15766 *
15767 * @params[in] transId
15768 * @return void
15769 *
15770 * ****************************************************************/
15771
15772 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
15773 {
15774    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
15775    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
15776    uint16_t cellIdx =0, crnti=0;
15777    uint64_t cellId =0;
15778    CmLList *f1apPduNode = NULLP;
15779    ReservedF1apPduInfo *f1apPduInfo =NULLP;
15780    F1AP_PDU_t *f1apMsgPdu = NULLP;
15781    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
15782    BIT_STRING_t *cellIdentity=NULLP;
15783    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
15784    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
15785    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
15786
15787    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
15788    f1apPduNode = searchFromReservedF1apPduList(transId);
15789    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
15790    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
15791
15792    if(f1apMsgPdu)
15793    {
15794       if(f1apMsgPdu->choice.initiatingMessage)
15795       {
15796          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
15797          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
15798          {
15799             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
15800             {
15801                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
15802                   {
15803                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
15804                                      Served_Cells_To_Delete_List;
15805                      if(cellsToDelete->list.array)
15806                      {
15807                         if(cellsToDelete->list.array[arrIdx])
15808                         {
15809                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
15810                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
15811                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
15812                            {
15813                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
15814                               bitStringToInt(cellIdentity, &cellId);
15815
15816                               GET_CELL_IDX(cellId, cellIdx);
15817                               if(duCb.actvCellLst[cellIdx] != NULLP)
15818                               {
15819                                  duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
15820                               }
15821                            }
15822                         }
15823                      }
15824
15825                      if(duCb.actvCellLst[cellIdx] != NULLP)
15826                      {
15827                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
15828                         {
15829                            ret = duSendCellDeletReq(cellId);
15830                            if(ret == RFAILED)
15831                            {
15832                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
15833                               request for cellId[%lu]", cellId);
15834                            }
15835                         }
15836                         else
15837                         {
15838                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
15839                            while(totalActiveUe)
15840                            {
15841                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
15842                               {
15843                                  ueIdx++;
15844                                  continue;
15845                               }
15846
15847                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
15848                               GET_UE_ID(crnti,ueId);
15849                               /* Sending Ue Context release request only for maximum supporting UEs */
15850                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
15851                               if(ret == RFAILED)
15852                               {
15853                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
15854                                  request for cellId[%lu]", cellId);
15855                               }
15856                               ueIdx++;
15857                               totalActiveUe--;
15858                            }
15859                         }
15860                      }
15861                      else
15862                      {
15863                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%lu] not found", cellId);
15864                         ret = RFAILED;
15865                      }
15866                      break;
15867                   }
15868
15869                default:
15870                   break;
15871             }
15872          }
15873       }
15874    }
15875
15876    FreeDUConfigUpdate(f1apMsgPdu);
15877    deleteFromReservedF1apPduList(f1apPduNode);
15878    return ret;
15879 }
15880
15881 /*******************************************************************
15882 *
15883 * @brief Processes GNB DU config update ack
15884 *
15885 * @details
15886 *
15887 *    Function : procF1GNBDUCfgUpdAck
15888 *
15889 *    Functionality: added free part for the memory allocated by aper_decoder
15890 *
15891 * @params[in] F1AP_PDU_t *f1apMsg,  MsgLen recvBufLen, char *recvBuf
15892 * @return void
15893 *
15894 * ****************************************************************/
15895
15896 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
15897 {
15898    uint8_t ieIdx=0,transId=0;
15899    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
15900
15901    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
15902    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
15903
15904    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15905    {
15906       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
15907       {
15908          case ProtocolIE_ID_id_TransactionID:
15909             {
15910                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
15911                break;
15912             }
15913          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15914             {
15915                break;
15916             }
15917          default :
15918             {
15919                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
15920                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
15921                break;
15922             }
15923       }
15924    }
15925
15926    duProcGnbDuCfgUpdAckMsg(transId);
15927
15928 #if 0
15929    /* presently we are not supporting F1 Reset from DU to CU , we are only
15930     * supporting F1 Reset from CU to DU */
15931
15932    if(BuildAndSendF1ResetReq() != ROK)
15933    {
15934       return RFAILED;
15935    }
15936 #endif
15937
15938    freeAperDecodeGnbDuAck(gnbDuAck);
15939
15940    if(fillE2NodeComponentRspInfo(F1,duCfgParam.duId, E2_NODE_COMPONENT_UPDATE, recvBufLen, recvBuf) !=ROK)
15941    {
15942       DU_LOG("\nERROR  -->  F1AP : Failed to update the e2 node in the list");
15943       return RFAILED;
15944    }
15945
15946    return ROK;
15947 }
15948 /******************************************************************
15949 *
15950 * @brief free DL RRC Message Transfer allocated by aper_decoder
15951 *
15952 * @details
15953 *
15954 *    Function : freeAperDecodef1DlRrcMsg
15955 *
15956 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
15957 *
15958 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
15959 * @return ROK     - success
15960 *         RFAILED - failure
15961 *
15962 * ****************************************************************/
15963
15964 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
15965 {
15966    uint8_t ieIdx =0;
15967    RRCContainer_t *rrcContainer = NULLP;
15968
15969    if(f1DlRrcMsg->protocolIEs.list.array)
15970    {
15971       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
15972       {
15973          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
15974          {
15975             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
15976             {
15977                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15978                   break;
15979                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15980                   break;
15981                case ProtocolIE_ID_id_SRBID:
15982                   break;
15983                case ProtocolIE_ID_id_RRCContainer:
15984                   {
15985                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
15986                      free(rrcContainer->buf);
15987                   }
15988                case ProtocolIE_ID_id_ExecuteDuplication:
15989                   break;
15990                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15991                   break;
15992                   break;
15993             }
15994             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
15995          }
15996       }
15997       free(f1DlRrcMsg->protocolIEs.list.array);
15998    }
15999 }
16000 /******************************************************************
16001  *
16002  * @brief Processes DL RRC Message Transfer  sent by CU
16003  *
16004  * @details
16005  *
16006  *    Function : procF1DlRrcMsgTrans
16007  *
16008  *    Functionality: Processes DL RRC Message Transfer sent by CU
16009  *
16010  * @params[in] F1AP_PDU_t ASN decoded F1AP message
16011  * @return ROK     - success
16012  *         RFAILED - failure
16013  *
16014  * ****************************************************************/
16015 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
16016 {
16017    uint8_t  idx, ret;
16018    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
16019    F1DlRrcMsg dlMsg;
16020    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
16021
16022    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
16023    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
16024
16025    ret = ROK;
16026
16027    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
16028    {
16029       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
16030       {
16031          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16032             {
16033                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
16034                break;
16035             }
16036          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16037             {
16038                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
16039                break;
16040             }
16041          case ProtocolIE_ID_id_SRBID:
16042             {
16043                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
16044                break;
16045             }
16046          case ProtocolIE_ID_id_ExecuteDuplication:
16047             dlMsg.execDup = true;
16048             break;
16049
16050          case ProtocolIE_ID_id_RRCContainer:
16051             {
16052                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
16053                {
16054              dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
16055              DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
16056              if(dlMsg.rrcMsgPdu)
16057              {
16058                 memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
16059                       dlMsg.rrcMsgSize);
16060              }
16061              else
16062              {
16063                 DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
16064                 return RFAILED;
16065              }
16066           }
16067           else
16068           {
16069              DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
16070                    f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
16071              return RFAILED;
16072           }
16073           break;
16074        }
16075     case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
16076        {
16077           dlMsg.deliveryStatRpt = true;
16078           break;
16079        }
16080     default:
16081        DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
16082              f1DlRrcMsg->protocolIEs.list.array[idx]->id);
16083       }
16084    }
16085
16086    ret = duProcDlRrcMsg(&dlMsg);
16087
16088    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
16089    return ret;
16090 }
16091 /*******************************************************************
16092  *
16093 * @brief Builds the DRB to be Setup Mod list
16094 *
16095 * @details
16096 *
16097 *    Function :
16098 *
16099 *    Functionality: Constructs the DRB to be Setup Mod list
16100 *
16101 * @params[in] DRBs_SetupMod_List_t *drbSet
16102 *
16103 * @return ROK     - success
16104 *         RFAILED - failure
16105 *
16106 * ****************************************************************/
16107 uint8_t BuildSrbSetupModList(SRBs_SetupMod_List_t *srbList, DuUeCfg *ueCfg)
16108 {
16109    uint8_t srbIdx = 0;
16110    struct SRBs_SetupMod_ItemIEs *srbItemIe;
16111
16112    srbList->list.count = ueCfg->numRlcLcs;
16113    srbList->list.size = srbList->list.count * sizeof(SRBs_SetupMod_ItemIEs_t *);
16114
16115    DU_ALLOC(srbList->list.array, srbList->list.size);
16116    if(srbList->list.array == NULLP)
16117    {
16118       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
16119       return RFAILED;
16120    }
16121
16122    for(srbIdx = 0; srbIdx < srbList->list.count; srbIdx++)
16123    {
16124       DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
16125       if(srbList->list.array[srbIdx] == NULLP)
16126       {
16127          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
16128          return RFAILED;
16129       }
16130    }
16131
16132    for(srbIdx=0; srbIdx < srbList->list.count; srbIdx++)
16133    {
16134       srbItemIe = (struct SRBs_SetupMod_ItemIEs *)srbList->list.array[srbIdx];
16135       srbItemIe->id = ProtocolIE_ID_id_SRBs_SetupMod_Item;
16136       srbItemIe->criticality = Criticality_reject;
16137       srbItemIe->value.present = SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item;
16138       srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID = ueCfg->rlcLcCfg[srbIdx].rlcBearerCfg.rbId;
16139       srbItemIe->value.choice.SRBs_SetupMod_Item.lCID = ueCfg->rlcLcCfg[srbIdx].rlcBearerCfg.lcId;
16140    }
16141    return ROK;
16142 }
16143
16144 /*******************************************************************
16145  *
16146 * @brief Builds the DRB to be Setup Mod list
16147 *
16148 * @details
16149 *
16150 *    Function :
16151 *
16152 *    Functionality: Constructs the DRB to be Setup Mod list
16153 *
16154 * @params[in] DRBs_SetupMod_List_t *drbSet
16155 *
16156 * @return ROK     - success
16157 *         RFAILED - failure
16158 *
16159 * ****************************************************************/
16160
16161 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
16162 {
16163    uint8_t arrIdx =0;
16164    uint8_t drbCnt =0;
16165    struct DRBs_SetupMod_ItemIEs *drbItemIe;
16166
16167    drbCnt = ueCfg->numDrbSetupMod;
16168
16169    drbSet->list.count = drbCnt;
16170    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
16171    DU_ALLOC(drbSet->list.array, drbSet->list.size);
16172    if(drbSet->list.array == NULLP)
16173    {
16174       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
16175       return  RFAILED;
16176    }
16177    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
16178    {
16179       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
16180       if(drbSet->list.array[arrIdx] == NULLP)
16181       {
16182               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
16183               return  RFAILED;
16184       }
16185
16186       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
16187       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
16188       drbItemIe->criticality = Criticality_reject;
16189       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
16190       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
16191       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
16192       &ueCfg->upTnlInfo[arrIdx])!= ROK)
16193       {
16194          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
16195          return RFAILED;
16196       }
16197
16198    }
16199
16200    return ROK;
16201 }
16202 /*******************************************************************
16203 * @brief Free the memory allocated for DRB setup List
16204 *
16205 * @details
16206 *
16207 *    Function : FreeDrbSetupModList
16208 *
16209 *    Functionality:
16210 *       Free the memory allocated for DRB setup list
16211 *
16212 * @params[in] DRBs_Setup_List_t *
16213 * @return void
16214 *
16215 * ****************************************************************/
16216 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
16217 {
16218    uint8_t arrIdx = 0;
16219    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
16220
16221    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
16222    {
16223       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
16224       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
16225       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
16226    }
16227    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
16228 }
16229
16230 /*******************************************************************
16231 *
16232 * @brief Builds the DRB to be Mod list
16233 *
16234 * @details
16235 *
16236 *    Function :
16237 *
16238 *    Functionality: Constructs the DRB to be Mod list
16239 *
16240 * @params[in] DRBs_Modified_List_t *drbModList
16241 *
16242 * @return ROK     - success
16243 *         RFAILED - failure
16244 *
16245 * ****************************************************************/
16246
16247 uint8_t BuildDrbModList(DRBs_Modified_List_t *drbModList, DuUeCfg *ueCfg)
16248 {
16249    uint8_t arrIdx =0, drbIdx = 0;
16250    uint8_t drbCnt =0;
16251    struct DRBs_Modified_ItemIEs *drbItemIe;
16252
16253    drbCnt = ueCfg->numDrbModified;
16254
16255    drbModList->list.count = drbCnt;
16256    drbModList->list.size = drbCnt * sizeof(DRBs_Modified_ItemIEs_t *);
16257    DU_ALLOC(drbModList->list.array, drbModList->list.size);
16258    if(drbModList->list.array == NULLP)
16259    {
16260       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbModList()");
16261       return  RFAILED;
16262    }
16263
16264    drbIdx = 0;
16265    for(arrIdx = 0; arrIdx < ueCfg->numMacLcs; arrIdx++)
16266    {
16267       if(ueCfg->macLcCfg[arrIdx].configType == CONFIG_MOD)
16268       {
16269          DU_ALLOC(drbModList->list.array[drbIdx], sizeof(DRBs_Modified_ItemIEs_t));
16270          if(drbModList->list.array[drbIdx] == NULLP)
16271          {
16272             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbModList");
16273             return  RFAILED;
16274          }
16275
16276          drbItemIe = (struct DRBs_Modified_ItemIEs *)drbModList->list.array[drbIdx];
16277          drbItemIe->id = ProtocolIE_ID_id_DRBs_Modified_Item;
16278          drbItemIe->criticality = Criticality_reject;
16279          drbItemIe->value.present = DRBs_Modified_ItemIEs__value_PR_DRBs_Modified_Item;
16280          drbItemIe->value.choice.DRBs_Modified_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
16281          if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Modified_Item.dLUPTNLInformation_ToBeSetup_List,\
16282                   &ueCfg->upTnlInfo[arrIdx])!= ROK)
16283          {
16284             DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbModList");
16285             return RFAILED;
16286          }
16287          drbIdx++;
16288       }
16289    }
16290
16291    return ROK;
16292 }
16293
16294 /*******************************************************************
16295 * @brief Free the memory allocated for DRB Mod List
16296 *
16297 * @details
16298 *
16299 *    Function : FreeDrbModList
16300 *
16301 *    Functionality:
16302 *       Free the memory allocated for DRB modified list
16303 *
16304 * @params[in] DRBs_Modified_List_t *
16305 * @return void
16306 *
16307 * ****************************************************************/
16308 void FreeDrbModList(DRBs_Modified_List_t *drbModList)
16309 {
16310    uint8_t arrIdx = 0;
16311    DRBs_Modified_ItemIEs_t *drbItemIe = NULLP;
16312
16313    for(arrIdx = 0; arrIdx < drbModList->list.count; arrIdx++)
16314    {
16315       drbItemIe = ((DRBs_Modified_ItemIEs_t *)drbModList->list.array[arrIdx]);
16316       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Modified_Item.dLUPTNLInformation_ToBeSetup_List);
16317       DU_FREE(drbModList->list.array[arrIdx], sizeof(DRBs_Modified_ItemIEs_t));
16318    }
16319    DU_FREE(drbModList->list.array, drbModList->list.size);
16320 }
16321
16322 /*******************************************************************
16323 * @brief Free the memory allocated for SRB setup List
16324 *
16325 * @details
16326 *
16327 *    Function : FreeSrbSetupModList
16328 *
16329 *    Functionality:
16330 *       Free the memory allocated for SRB setup list
16331 *
16332 * @params[in] SRBs_Setup_List_t *
16333 * @return void
16334 *
16335 * ****************************************************************/
16336 void FreeSrbSetupModList(SRBs_SetupMod_List_t *srbSetupList)
16337 {
16338    uint8_t srbIdx = 0;
16339
16340    for(srbIdx = 0; srbIdx < srbSetupList->list.count; srbIdx++)
16341       DU_FREE(srbSetupList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
16342    DU_FREE(srbSetupList->list.array, srbSetupList->list.size);
16343 }
16344
16345 /*******************************************************************
16346 * @brief Free the memory allocated for UE Context Mod Response
16347 *
16348 * @details
16349 *
16350 *    Function : FreeUeContextModResp
16351 *
16352 *    Functionality:
16353 *       Free the memory allocated for UE Context Mod Response
16354 *
16355 * @params[in] F1AP_PDU_t *f1apMsg
16356 * @return void
16357 *
16358 * ****************************************************************/
16359
16360 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
16361 {
16362    uint8_t ieIdx;
16363    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
16364    if(f1apMsg)
16365    {
16366       if(f1apMsg->choice.successfulOutcome)
16367       {
16368          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
16369          if(ueContextModifyRes->protocolIEs.list.array)
16370          {
16371             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
16372             {
16373                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
16374                {
16375                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
16376                   {
16377                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16378                         break;
16379                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16380                         break;
16381                      case ProtocolIE_ID_id_DUtoCURRCInformation:
16382                         {
16383                            DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.\
16384                               cellGroupConfig.buf, ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
16385                               DUtoCURRCInformation.cellGroupConfig.size);
16386                            break;
16387                         }
16388                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
16389                         {
16390                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
16391                             value.choice.DRBs_SetupMod_List));
16392                             break;
16393                         }
16394                      case ProtocolIE_ID_id_DRBs_Modified_List:
16395                         {
16396                             FreeDrbModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
16397                             value.choice.DRBs_Modified_List));
16398                             break;
16399                         }
16400                      case ProtocolIE_ID_id_SRBs_SetupMod_List:
16401                         {
16402                            FreeSrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
16403                               SRBs_SetupMod_List));
16404                            break;
16405                         }
16406                   }
16407                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
16408                }
16409
16410             }
16411             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
16412          }
16413          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16414       }
16415       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16416    }
16417 }
16418
16419 /*****************************************************************i
16420 *
16421 * @brief Creating the ue context modifcation response and sending
16422 *
16423 * @details
16424 *
16425 *    Function : BuildAndSendUeContextModRsp
16426 *
16427 *    Functionality:
16428 *         - Creating the ue context modifcation response
16429 *
16430 * @params[in] uint8_t cellId,uint8_t ueId
16431 * @return ROK     - success
16432 *         RFAILED - failure
16433 *
16434 * ****************************************************************/
16435 uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb)
16436 {
16437    uint8_t   ieIdx = 0, tnlIdx = 0, rbIdx = 0;
16438    uint8_t   elementCnt = 0;
16439    uint8_t   ret = RFAILED;
16440    F1AP_PDU_t *f1apMsg = NULLP;
16441    asn_enc_rval_t  encRetVal;
16442    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
16443
16444    DU_LOG("\nINFO  -->  F1AP : Building UE context modification response\n");
16445
16446    while(true)
16447    {
16448       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16449       if(f1apMsg == NULLP)
16450       {
16451          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
16452          break;
16453       }
16454
16455       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
16456
16457       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16458       if(f1apMsg->choice.successfulOutcome == NULLP)
16459       {
16460          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
16461          break;
16462       }
16463       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
16464       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
16465       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
16466
16467       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
16468
16469       if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
16470       {
16471          elementCnt = 2;
16472          if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
16473             elementCnt++;
16474          if(ueCb->f1UeDb->duUeCfg.numDrbModified)
16475             elementCnt++;
16476       }
16477       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
16478       {
16479          elementCnt = 5;
16480       }
16481       if(ueCb->f1UeDb->actionType == UE_CTXT_RRC_RECFG_COMPLETE)
16482          elementCnt = 2;
16483       ueContextModifyRes->protocolIEs.list.count = elementCnt;
16484       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
16485
16486       /* Initialize the UE context modification members */
16487       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
16488       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
16489       {
16490          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
16491          break;
16492       }
16493
16494       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
16495       {
16496          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
16497          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
16498          {
16499             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
16500             break;
16501          }
16502       }
16503
16504       ieIdx=0;
16505       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16506       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16507       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
16508       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
16509       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
16510
16511       ieIdx++;
16512       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16513       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16514       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
16515       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
16516       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
16517
16518       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
16519       {
16520          ieIdx++;
16521          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCInformation;
16522          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16523          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
16524          UEContextModificationResponseIEs__value_PR_DUtoCURRCInformation;
16525          BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
16526       }
16527
16528       if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || \
16529            ((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbSetupMod)))
16530       {
16531          ieIdx++;
16532          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
16533          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16534          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
16535                                                                            UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
16536          if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
16537          {
16538             for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
16539             {
16540                if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
16541                {
16542                   memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
16543                }
16544             }
16545          }
16546          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
16547                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
16548          if(ret != ROK)
16549          {
16550             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB setupmod List ");
16551             break;
16552          }
16553       }
16554
16555       if((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbModified))
16556       {
16557          ieIdx++;
16558          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_Modified_List;
16559          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16560          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
16561                                                                     UEContextModificationResponseIEs__value_PR_DRBs_Modified_List;
16562          ret = BuildDrbModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
16563                                  value.choice.DRBs_Modified_List) , &ueCb->f1UeDb->duUeCfg);
16564          if(ret != ROK)
16565          {
16566             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB Modified List ");
16567             break;
16568          }
16569       }
16570
16571       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
16572       {
16573          ieIdx++;
16574          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_SRBs_SetupMod_List;
16575          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16576          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
16577                                                                             UEContextModificationResponseIEs__value_PR_SRBs_SetupMod_List;
16578          for(rbIdx = 0; rbIdx < ueCb->duRlcUeCfg.numLcs; rbIdx++)
16579          {
16580             if(ueCb->duRlcUeCfg.rlcLcCfg[rbIdx].rlcBearerCfg.rbType == RB_TYPE_SRB)
16581             {
16582                memcpy(&ueCb->f1UeDb->duUeCfg.rlcLcCfg[ueCb->f1UeDb->duUeCfg.numRlcLcs++], &ueCb->duRlcUeCfg.rlcLcCfg[rbIdx],\
16583                      sizeof(DuRlcBearerCfg));
16584             }
16585          }
16586          ret = BuildSrbSetupModList(&ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.SRBs_SetupMod_List, \
16587                &ueCb->f1UeDb->duUeCfg);
16588          if(ret != ROK)
16589          {
16590             DU_LOG( "\nERROR  -->  F1AP : Failed to build SRB setupmod List ");
16591             break;
16592          }
16593       }
16594
16595       freeF1UeDb(ueCb->f1UeDb);
16596       ueCb->f1UeDb = NULLP;
16597
16598       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16599
16600       /* Encode the F1SetupRequest type as APER */
16601       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16602       encBufSize = 0;
16603       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
16604
16605       /* Encode results */
16606       if(encRetVal.encoded == ENCODE_FAIL)
16607       {
16608          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Modification Response structure (at %s)\n",\
16609                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16610          ret = RFAILED;
16611          break;
16612       }
16613       else
16614       {
16615          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
16616 #ifdef DEBUG_ASN_PRINT
16617          for(int i=0; i< encBufSize; i++)
16618          {
16619             printf("%x",encBuf[i]);
16620          }
16621 #endif
16622       }
16623
16624       /* Sending  msg  */
16625       if(sendF1APMsg() != ROK && (ret == ROK))
16626       {
16627          DU_LOG("\nERROR  -->  F1AP : Sending UE Modification Res Failed");
16628          ret = RFAILED;
16629          break;
16630       }
16631
16632       ret = ROK;
16633       break;
16634    }
16635
16636    FreeUeContextModResp(f1apMsg);
16637    return ret;
16638 }
16639
16640 /*******************************************************************
16641  *
16642  * @brief Deallocating the memory allocated by the aper decoder
16643  *          for QOSInfo
16644  *
16645  * @details
16646  *
16647  *    Function : freeAperDecodeQosInfo
16648  *
16649  *    Functionality:  Deallocating the memory allocated for QOSInfo
16650  *
16651  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
16652  *
16653  * @return void
16654  *
16655  * ****************************************************************/
16656
16657 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
16658 {
16659    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
16660    {
16661       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
16662       {
16663          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
16664          {
16665             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
16666          }
16667          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
16668       }
16669       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
16670    }
16671 }
16672 /*******************************************************************
16673  *
16674  * @brief Deallocating the memory allocated by the aper decoder
16675  *          for UlTnlInfoforDrb
16676  *
16677  * @details
16678  *
16679  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
16680  *
16681  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
16682  *
16683  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
16684  *
16685  * @return void
16686  *
16687  * ****************************************************************/
16688 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
16689 {
16690    uint8_t arrIdx =0;
16691
16692    if(ulInfo->list.array)
16693    {
16694       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
16695       {
16696          if(ulInfo->list.array[arrIdx])
16697          {
16698             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
16699             {
16700                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
16701                {
16702                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
16703                   {
16704                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16705                            gTP_TEID.buf);
16706                   }
16707                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16708                         transportLayerAddress.buf);
16709                }
16710                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
16711             }
16712             free(ulInfo->list.array[arrIdx]);
16713          }
16714       }
16715       free(ulInfo->list.array);
16716    }
16717 }
16718
16719 /*******************************************************************
16720  *
16721  * @brief Deallocating the memory allocated by the aper decoder
16722  *          for DrbSetupModItem
16723  *
16724  * @details
16725  *
16726  *    Function : freeAperDecodeDrbSetupModItem
16727  *
16728  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
16729  *
16730  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
16731  *
16732  * @return void
16733  *
16734  * ****************************************************************/
16735
16736 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
16737 {
16738    uint8_t arrIdx =0;
16739    SNSSAI_t *snssai =NULLP;
16740    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
16741
16742    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
16743    switch(drbItem->qoSInformation.present)
16744    {
16745       case QoSInformation_PR_NOTHING:
16746          break;
16747       case QoSInformation_PR_eUTRANQoS:
16748          {
16749             if(drbItem->qoSInformation.choice.eUTRANQoS)
16750             {
16751                free(drbItem->qoSInformation.choice.eUTRANQoS);
16752             }
16753             break;
16754          }
16755       case QoSInformation_PR_choice_extension:
16756          {
16757             if(drbItem->qoSInformation.choice.choice_extension)
16758             {
16759                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
16760                      DRB_Information.dRB_QoS);
16761                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
16762                if(snssai->sST.buf)
16763                {
16764                   free(snssai->sST.buf);
16765                }
16766                if(snssai->sD)
16767                {
16768                   if(snssai->sD->buf)
16769                   {
16770                      free(snssai->sD->buf);
16771                   }
16772                   free(snssai->sD);
16773                }
16774
16775                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
16776                          DRB_Information.flows_Mapped_To_DRB_List;
16777                if(flowMap->list.array)
16778                {
16779                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
16780                   {
16781                      if(flowMap->list.array[arrIdx] )
16782                      {
16783                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
16784                         free(flowMap->list.array[arrIdx]);
16785                      }
16786                   }
16787                   free(flowMap->list.array);
16788                }
16789
16790                free(drbItem->qoSInformation.choice.choice_extension);
16791             }
16792             break;
16793          }
16794
16795    }
16796    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
16797    if(drbItem->uLConfiguration)
16798    {
16799       free(drbItem->uLConfiguration);
16800    }
16801 }
16802
16803 /*******************************************************************
16804  *
16805  * @brief Deallocating the memory allocated by the aper decoder
16806  *          for DrbToBeSetupModList
16807  *
16808  * @details
16809  *
16810  *    Function : freeAperDecodeDrbToBeSetupModList
16811  *
16812  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
16813  *
16814  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
16815  *
16816  * @return void
16817  *
16818  * ****************************************************************/
16819
16820 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
16821 {
16822    uint8_t arrIdx =0;
16823    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
16824
16825    if(drbSet->list.array)
16826    {
16827       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
16828       {
16829          if(drbSet->list.array[arrIdx] != NULLP)
16830          {
16831             if(arrIdx == 0)
16832             {
16833                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
16834                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
16835             }
16836             free(drbSet->list.array[arrIdx]);
16837          }
16838       }
16839       free(drbSet->list.array);
16840    }
16841
16842 }
16843
16844 /*******************************************************************
16845  *
16846  * @brief Deallocating the memory allocated by the aper decoder
16847  *          for DrbSetupModItem
16848  *
16849  * @details
16850  *
16851  *    Function : freeAperDecodeDrbModifiedItem
16852  *
16853  *    Functionality:  Deallocating memory allocated for DrbModifedItem
16854  *
16855  * @params[in] DRBs_ToBeModified_Item_t *drbItem
16856  *
16857  * @return void
16858  *
16859  * ****************************************************************/
16860
16861 void freeAperDecodeDrbModifiedItem(DRBs_ToBeModified_Item_t *drbItem)
16862 {
16863    uint8_t arrIdx =0;
16864    SNSSAI_t *snssai =NULLP;
16865    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
16866
16867    if(drbItem->qoSInformation != NULLP)
16868    {
16869       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
16870       switch(drbItem->qoSInformation->present)
16871       {
16872          case QoSInformation_PR_NOTHING:
16873             break;
16874          case QoSInformation_PR_eUTRANQoS:
16875             {
16876                if(drbItem->qoSInformation->choice.eUTRANQoS)
16877                {
16878                   free(drbItem->qoSInformation->choice.eUTRANQoS);
16879                }
16880                break;
16881             }
16882          case QoSInformation_PR_choice_extension:
16883             {
16884                if(drbItem->qoSInformation->choice.choice_extension)
16885                {
16886                   freeAperDecodeQosInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.\
16887                         DRB_Information.dRB_QoS);
16888                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
16889                   if(snssai->sST.buf)
16890                   {
16891                      free(snssai->sST.buf);
16892                   }
16893                   if(snssai->sD)
16894                   {
16895                      if(snssai->sD->buf)
16896                      {
16897                         free(snssai->sD->buf);
16898                      }
16899                      free(snssai->sD);
16900                   }
16901
16902                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.\
16903                             DRB_Information.flows_Mapped_To_DRB_List;
16904                   if(flowMap->list.array)
16905                   {
16906                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
16907                      {
16908                         if(flowMap->list.array[arrIdx] )
16909                         {
16910                            freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
16911                            free(flowMap->list.array[arrIdx]);
16912                         }
16913                      }
16914                      free(flowMap->list.array);
16915                   }
16916
16917                   free(drbItem->qoSInformation->choice.choice_extension);
16918                }
16919                break;
16920             }
16921       }
16922       free(drbItem->qoSInformation);
16923    }
16924    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
16925    if(drbItem->uLConfiguration)
16926    {
16927       free(drbItem->uLConfiguration);
16928    }
16929 }
16930
16931 /*******************************************************************
16932  *
16933  * @brief Deallocating the memory allocated by the aper decoder
16934  *          for DrbToBeSetupModList
16935  *
16936  * @details
16937  *
16938  *    Function : freeAperDecodeDrbToBeModifiedList
16939  *
16940  *    Functionality:  Deallocating memory allocated for DrbToBeModifiedList
16941  *
16942  * @params[in] DRBs_ToBeModified_List_t *drbSet
16943  *
16944  * @return void
16945  *
16946  * ****************************************************************/
16947
16948 void freeAperDecodeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
16949 {
16950    uint8_t arrIdx =0;
16951    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
16952
16953    if(drbSet->list.array)
16954    {
16955       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
16956       {
16957          if(drbSet->list.array[arrIdx] != NULLP)
16958          {
16959             if(arrIdx == 0)
16960             {
16961                drbItemIe = (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx];
16962                freeAperDecodeDrbModifiedItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
16963             }
16964             free(drbSet->list.array[arrIdx]);
16965          }
16966       }
16967       free(drbSet->list.array);
16968    }
16969
16970 }
16971
16972 /*******************************************************************
16973  *
16974  * @brief Deallocating the memory allocated by the aper decoder
16975  *          for DrbToBeSetupModList
16976  *
16977  * @details
16978  *
16979  *    Function : freeAperDecodeDrbToBeReleasedList
16980  *
16981  *    Functionality:  Deallocating memory allocated for DrbToBeReleasedList
16982  *
16983  * @params[in] DRBs_ToBeReleased_List_t *drbSet
16984  *
16985  * @return void
16986  *
16987  * ****************************************************************/
16988
16989 void freeAperDecodeDrbToBeReleasedList(DRBs_ToBeReleased_List_t *drbSet)
16990 {
16991    uint8_t arrIdx =0;
16992
16993    if(drbSet->list.array)
16994    {
16995       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
16996       {
16997          if(drbSet->list.array[arrIdx] != NULLP)
16998          {
16999             free(drbSet->list.array[arrIdx]);
17000          }
17001       }
17002       free(drbSet->list.array);
17003    }
17004
17005 }
17006 /*******************************************************************
17007  *
17008  * @brief Deallocating the memory allocated by the aper decoder
17009  *          for UeContextModificationReqMsg
17010  *
17011  * @details
17012  *
17013  *    Function : freeAperDecodeUeContextModificationReqMsg
17014  *
17015  *    Functionality:  Deallocating memory allocated for
17016  *                  UeContextModificationReqMsg
17017  *
17018  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
17019  *
17020  * @return void
17021  *
17022  * ****************************************************************/
17023 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *ueContextModifyReq )
17024 {
17025    uint8_t arrIdx, ieId;
17026
17027    if(ueContextModifyReq->protocolIEs.list.array)
17028    {
17029       for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
17030       {
17031          if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
17032          {
17033             ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
17034             switch(ieId)
17035             {
17036                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
17037                   break;
17038                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
17039                   break;
17040                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
17041                   {
17042                      freeAperDecodeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
17043                            value.choice.DRBs_ToBeSetupMod_List);
17044                      break;
17045                   }
17046                case ProtocolIE_ID_id_DRBs_ToBeModified_List:
17047                   {
17048                      freeAperDecodeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
17049                            value.choice.DRBs_ToBeModified_List);
17050                      break;
17051                   }
17052                case ProtocolIE_ID_id_DRBs_ToBeReleased_List:
17053                   {
17054                      freeAperDecodeDrbToBeReleasedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
17055                            value.choice.DRBs_ToBeReleased_List);
17056                      break;
17057                   }
17058                case ProtocolIE_ID_id_TransmissionActionIndicator:
17059                   break;
17060                case ProtocolIE_ID_id_RRCContainer:
17061                   {
17062                      free(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf);
17063                   }
17064             }
17065             free(ueContextModifyReq->protocolIEs.list.array[arrIdx]);
17066          }
17067       }
17068       free(ueContextModifyReq->protocolIEs.list.array);
17069    }
17070 }
17071 /*******************************************************************
17072  *
17073  * @brief processing the F1 UeContextModificationReq
17074  *
17075  * @details
17076  *
17077  *    Function : procF1UeContextModificationReq
17078  *
17079  *    Functionality:  processing the F1 UeContextModificationReq
17080  *
17081  * @params[in] F1AP_PDU_t *f1apMsg
17082  *
17083  * @return
17084  * ****************************************************************/
17085 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
17086 {
17087    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
17088    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0;
17089    DuUeCb   *duUeCb = NULLP;
17090    DRBs_ToBeSetupMod_List_t *drbSetupModCfg = NULLP;
17091    DRBs_ToBeModified_List_t *drbModifiedCfg = NULLP;
17092    DRBs_ToBeReleased_List_t *drbToRelease = NULLP;
17093    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
17094
17095    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
17096    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
17097    {
17098       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
17099       {
17100          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
17101             {
17102                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
17103                break;
17104             }
17105          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
17106             {
17107                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
17108                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
17109                {
17110                   if(duCb.actvCellLst[cellIdx])
17111                   {
17112                      if((duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == gnbDuUeF1apId)&&\
17113                            (duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbCuUeF1apId == gnbCuUeF1apId))
17114                      {
17115                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1];
17116                         if(duUeCb->f1UeDb == NULLP)
17117                         {
17118                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
17119                            duUeCb->f1UeDb->cellIdx = cellIdx;
17120                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
17121                         }
17122                         break;
17123                      }
17124                   }
17125                }
17126                if(duUeCb == NULLP)
17127                {
17128                   DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
17129                   ret = RFAILED;
17130                }
17131                break;
17132             }
17133
17134          case ProtocolIE_ID_id_RRCContainer:
17135             {
17136                /* Filling Dl RRC Msg Info */
17137                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
17138                if(!duUeCb->f1UeDb->dlRrcMsg)
17139                {
17140                   DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
17141                         Memory allocation failed ");
17142                   ret = RFAILED;
17143                }
17144                else
17145                {
17146                   duUeCb->f1UeDb->dlRrcMsgPres = true;
17147                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
17148                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
17149                         &ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
17150                         value.choice.RRCContainer);
17151                }
17152
17153                break;
17154             }
17155
17156          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
17157          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
17158          case ProtocolIE_ID_id_DRBs_ToBeReleased_List:
17159             {
17160                if(duUeCb->f1UeDb)
17161                {
17162                   /*DRBs to be Added*/
17163                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
17164                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
17165                   {
17166                      drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
17167                                       choice.DRBs_ToBeSetupMod_List;
17168
17169                      if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
17170                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
17171                      {
17172                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
17173                         ret = RFAILED;
17174                      }
17175                   }
17176
17177                   /*DRBs to be Modified*/
17178                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
17179                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
17180
17181                   {
17182                      drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
17183                                       choice.DRBs_ToBeModified_List;
17184                      if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
17185                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->duRlcUeCfg))
17186                      {
17187                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
17188                         ret = RFAILED;
17189                      }
17190                   }
17191                   /*DRBs to be Released*/
17192                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
17193                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeReleased_List)
17194
17195                   {
17196                      drbToRelease = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
17197                                       choice.DRBs_ToBeReleased_List;
17198                      if(extractDrbListToRelease(gnbDuUeF1apId, drbToRelease, drbToRelease->list.count,\
17199                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->duRlcUeCfg))
17200                      {
17201                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
17202                         ret = RFAILED;
17203                      }
17204                   }
17205                }
17206                break;
17207             }
17208
17209          case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
17210             {
17211                DU_LOG("\nINFO  -->  DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
17212                if(duUeCb->f1UeDb)
17213                {
17214                   duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
17215                }
17216                break;
17217             }
17218
17219          case ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator:
17220             {
17221                if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator == \
17222                   RRCReconfigurationCompleteIndicator_true)
17223                {
17224                   duUeCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE;
17225                }
17226                break;
17227             }
17228          case ProtocolIE_ID_id_TransmissionActionIndicator:
17229             {
17230                if(duUeCb->f1UeDb)
17231                {
17232                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator  == TransmissionActionIndicator_stop)
17233                   {
17234                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = STOP_TRANSMISSION;
17235                   }
17236                   else
17237                   {
17238                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = RESTART_TRANSMISSION;
17239                   }
17240                }
17241                break;
17242             }
17243
17244          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
17245             {
17246                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
17247                {
17248                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
17249                }
17250                break;
17251             }
17252 #ifdef NR_DRX
17253          case ProtocolIE_ID_id_DRXConfigurationIndicator:
17254             {
17255                duUeCb->f1UeDb->duUeCfg.drxConfigIndicatorRelease = true;
17256                break;
17257             }
17258 #endif
17259
17260       }
17261    }
17262
17263    if(ret != RFAILED)
17264    {
17265       ret = duProcUeContextModReq(duUeCb);
17266    }
17267    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
17268    return ret;
17269 }
17270
17271 /*****************************************************************i
17272 *
17273 * @brief Free memory allocated for UE Context Release Request
17274 *
17275 * @details
17276 *
17277 *    Function : FreeUeContextReleaseReq
17278 *
17279 *    Functionality:
17280 *         - Free memory allocated for UE Context Release Request
17281 *
17282 * @params[in] F1AP_PDU_t *f1apMsg
17283 * @return void
17284 *
17285 * *************************************************************/
17286 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
17287 {
17288    uint8_t ieIdx;
17289    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
17290
17291    if(f1apMsg)
17292    {
17293       if(f1apMsg->choice.initiatingMessage)
17294       {
17295          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
17296          if(ueReleaseReq->protocolIEs.list.array)
17297          {
17298             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
17299             {
17300                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
17301             }
17302             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
17303          }
17304          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
17305       }
17306       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
17307    }
17308
17309 }
17310 /*****************************************************************i
17311 *
17312 * @brief Build and Send UE Context Release Request
17313 *
17314 * @details
17315 *
17316 *    Function : BuildAndSendUeContextReleaseReq
17317 *
17318 *    Functionality:
17319 *         - Build and Send UE Context Release Request
17320 *
17321 * @params[in]
17322 * @return ROK     - success
17323 *         RFAILED - failure
17324 *
17325 * *************************************************************/
17326 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
17327 {
17328    bool memAllocFail = false;
17329    uint8_t ieIdx =0;
17330    uint8_t ret = RFAILED;
17331    uint16_t cellIdx =0;
17332    uint16_t crnti = 0;
17333    uint8_t  elementCnt = 0;
17334    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
17335    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
17336    asn_enc_rval_t encRetVal;
17337    F1AP_PDU_t *f1apMsg = NULLP;
17338    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
17339
17340    DU_LOG("\nINFO  --> Building the UE Context Release Request");
17341    do
17342    {
17343       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
17344       if(f1apMsg == NULLP)
17345       {
17346          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
17347          break;
17348       }
17349
17350       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
17351       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
17352       if(f1apMsg->choice.initiatingMessage == NULLP)
17353       {
17354          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
17355          initiatingMessage");
17356          break;
17357       }
17358       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
17359       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
17360       f1apMsg->choice.initiatingMessage->value.present = \
17361       InitiatingMessage__value_PR_UEContextReleaseRequest;
17362
17363       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
17364
17365       elementCnt = 2;
17366
17367       ueReleaseReq->protocolIEs.list.count = elementCnt;
17368       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
17369
17370       /* Initialize the F1Setup members */
17371       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
17372       if(ueReleaseReq->protocolIEs.list.array == NULLP)
17373       {
17374          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
17375          break;
17376       }
17377       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
17378       {
17379          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
17380                sizeof(UEContextReleaseRequest_t));
17381          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
17382          {
17383             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
17384             memAllocFail = true;
17385             break;
17386          }
17387       }
17388       if(memAllocFail == true)
17389          break;
17390
17391       /* Fetching Ue Cb Info*/
17392       GET_CELL_IDX(cellId, cellIdx);
17393       if(duCb.actvCellLst[cellIdx] == NULLP)
17394       {
17395          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
17396          break;
17397       }
17398       else
17399       {
17400          GET_CRNTI(crnti, ueId);
17401          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
17402          {
17403             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
17404             break;
17405          }
17406          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
17407          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
17408       }
17409
17410       ieIdx=0;
17411       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
17412       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
17413       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
17414       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
17415       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
17416
17417       ieIdx++;
17418       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
17419       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
17420       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
17421       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
17422       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
17423
17424       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
17425
17426       /* Encode the F1SetupRequest type as APER */
17427       memset(encBuf, 0, ENC_BUF_MAX_LEN);
17428       encBufSize = 0;
17429       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
17430       /* Encode results */
17431       if(encRetVal.encoded == ENCODE_FAIL)
17432       {
17433          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
17434                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
17435          break;
17436       }
17437       else
17438       {
17439          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
17440 #ifdef DEBUG_ASN_PRINT
17441          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
17442          {
17443             printf("%x",encBuf[ieIdx]);
17444          }
17445 #endif
17446       }
17447
17448       /* Sending msg */
17449       if(sendF1APMsg() != ROK)
17450       {
17451          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
17452          break;
17453       }
17454       ret = ROK;
17455       break;
17456    }while(true);
17457
17458    FreeUeContextReleaseReq(f1apMsg);
17459    return ret;
17460 }
17461 /*****************************************************************i
17462  *
17463  * @brief Free memory allocated for UE Context Release Complete
17464  *
17465  * @details
17466  *
17467  *    Function : FreeUeContextReleaseComplete
17468  *
17469  *    Functionality:
17470  *         - Free memory allocated for UE Context Release Complete
17471  *
17472  * @params[in] F1AP_PDU_t *f1apMsg
17473  * @return void
17474  *
17475  * *************************************************************/
17476 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
17477 {
17478    uint8_t ieIdx;
17479    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
17480
17481    if(f1apMsg)
17482    {
17483       if(f1apMsg->choice.successfulOutcome)
17484       {
17485          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
17486          if(ueReleaseComplete->protocolIEs.list.array)
17487          {
17488             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
17489             {
17490                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
17491             }
17492             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
17493          }
17494          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
17495       }
17496       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
17497    }
17498
17499 }
17500 /*****************************************************************i
17501  *
17502  * @brief Build and Send UE Context Release Complete
17503  *
17504  * @details
17505  *
17506  *    Function : BuildAndSendUeContextReleaseComplete
17507  *
17508  *    Functionality:
17509  *         - Build and Send UE Context Release Complete
17510  *
17511  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
17512  * @return ROK     - success
17513  *         RFAILED - failure
17514  *
17515  * *************************************************************/
17516 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
17517 {
17518    bool memAllocFail = false;
17519    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
17520    asn_enc_rval_t encRetVal;
17521    F1AP_PDU_t *f1apMsg = NULLP;
17522    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
17523
17524    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
17525    do
17526    {
17527       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
17528       if(f1apMsg == NULLP)
17529       {
17530          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
17531          break;
17532       }
17533
17534       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
17535       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
17536       if(f1apMsg->choice.successfulOutcome == NULLP)
17537       {
17538          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
17539                successfulOutcome");
17540          break;
17541       }
17542       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
17543       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
17544       f1apMsg->choice.successfulOutcome->value.present = \
17545       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
17546
17547       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
17548
17549       elementCnt = 2;
17550       ueReleaseComplete->protocolIEs.list.count = elementCnt;
17551       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
17552
17553       /* Initialize the UE Release Complete members */
17554       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
17555       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
17556       {
17557          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
17558          break;
17559       }
17560       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
17561       {
17562          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
17563                sizeof(UEContextReleaseComplete_t));
17564          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
17565          {
17566             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
17567             elements");
17568             memAllocFail = true;
17569             break;
17570          }
17571       }
17572       if(memAllocFail == true)
17573          break;
17574
17575
17576       ieIdx=0;
17577       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
17578       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
17579       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
17580       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
17581       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
17582
17583       ieIdx++;
17584       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
17585       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
17586       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
17587       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
17588       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
17589
17590       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
17591
17592       /* Encode the F1SetupComplete type as APER */
17593       memset(encBuf, 0, ENC_BUF_MAX_LEN);
17594       encBufSize = 0;
17595       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
17596       /* Encode results */
17597       if(encRetVal.encoded == ENCODE_FAIL)
17598       {
17599          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
17600                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
17601          break;
17602       }
17603       else
17604       {
17605          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
17606 #ifdef DEBUG_ASN_PRINT
17607          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
17608          {
17609             printf("%x",encBuf[ieIdx]);
17610          }
17611 #endif
17612       }
17613
17614       /* Sending msg */
17615       if(sendF1APMsg() != ROK)
17616       {
17617          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
17618          break;
17619       }
17620       ret = ROK;
17621       break;
17622    }while(true);
17623
17624    if((ret == ROK) && (duCb.actvCellLst[cellId-1]) && (duCb.actvCellLst[cellId-1]->cellStatus == DELETION_IN_PROGRESS)
17625          && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
17626    {
17627       ret = duSendCellDeletReq(cellId);
17628       if(ret != ROK)
17629       {
17630          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
17631                Delete req for CellId");
17632       }
17633    }
17634    FreeUeContextReleaseComplete(f1apMsg);
17635    return ret;
17636
17637 }
17638
17639 /*******************************************************************
17640 *
17641 * @brief added free part for the memory allocated by aper_decoder
17642 *
17643 * @details
17644 *
17645 *    Function : freeAperDecodeUeContextReleaseCommand
17646 *
17647 *    Functionality: added free part for the memory allocated by aper_decoder
17648 *
17649 * @params[in] F1AP_PDU_t *f1apMsg
17650 * @return void
17651 *
17652 * ****************************************************************/
17653 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
17654 {
17655    uint8_t ieIdx=0;
17656    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
17657
17658    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
17659
17660    if(ueContextReleaseCommand->protocolIEs.list.array)
17661    {
17662       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
17663       {
17664          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
17665          {
17666             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
17667             {
17668                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
17669                   break;
17670                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
17671                   break;
17672                case ProtocolIE_ID_id_Cause:
17673                   break;
17674                case ProtocolIE_ID_id_RRCContainer:
17675                {
17676                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
17677                   {
17678                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
17679                   }
17680                   break;
17681                }
17682                default :
17683                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
17684                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
17685                   break;
17686             }
17687          }
17688          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
17689       }
17690       free(ueContextReleaseCommand->protocolIEs.list.array);
17691    }
17692 }
17693 /*******************************************************************
17694 *
17695 * @brief processing of UE Context Release Command
17696 *
17697 * @details
17698 *
17699 *    Function : procF1UeContextReleaseCommand
17700 *
17701 *    Functionality: processing of UE Context Release Command
17702 *
17703 * @params[in] F1AP_PDU_t *f1apMsg
17704 * @return void
17705 *
17706 * ****************************************************************/
17707 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
17708 {
17709    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
17710    uint16_t cellIdx =0, cellId = 0;
17711    bool ueIdxFound = false;
17712    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
17713    DuUeCb   *duUeCb = NULLP;
17714    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
17715
17716    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
17717
17718    if(ueContextReleaseCommand->protocolIEs.list.array)
17719    {
17720       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
17721       {
17722          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
17723          {
17724             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
17725             {
17726                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
17727                   {
17728                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
17729                                     value.choice.GNB_CU_UE_F1AP_ID;
17730                      break;
17731                   }
17732
17733                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
17734                   {
17735                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
17736                                      value.choice.GNB_DU_UE_F1AP_ID;
17737                      break;
17738                   }
17739
17740                case ProtocolIE_ID_id_Cause:
17741                   {
17742                      for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
17743                      {
17744                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
17745                         {
17746                            if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
17747                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
17748                            {
17749                               cellId = duCb.actvCellLst[cellIdx]->cellId;
17750                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
17751                               ueIdxFound = true;
17752                               break;
17753                            }
17754                         }
17755                         if(ueIdxFound == true)
17756                         {
17757                            break;
17758                         }
17759                      }
17760
17761                      if(!ueIdxFound)
17762                      {
17763                         DU_LOG("\nERROR  -->  F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
17764                         ret = RFAILED;
17765                      }
17766                      break;
17767                   }
17768
17769                case ProtocolIE_ID_id_RRCContainer:
17770                   {
17771                      if(ueIdxFound == true)
17772                      {
17773                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
17774                         if(duUeCb->f1UeDb)
17775                         {
17776                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
17777                            duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
17778                            duUeCb->f1UeDb->cellIdx = cellIdx;
17779                            /* Filling Dl RRC Msg Info */
17780                            DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
17781                            if(!duUeCb->f1UeDb->dlRrcMsg)
17782                            {
17783                               DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
17784                                     Memory allocation failed ");
17785                               ret = RFAILED;
17786                            }
17787                            else
17788                            {
17789                               duUeCb->f1UeDb->dlRrcMsgPres = true;
17790                               memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
17791                               ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
17792                                     &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
17793                                     value.choice.RRCContainer);
17794                            }
17795
17796                         }
17797                         else
17798                         {
17799                            DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
17800                                  Memory allocation failed ");
17801                            ret = RFAILED;
17802
17803                         }
17804                      }
17805                      break;
17806                   }
17807                default :
17808                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
17809                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
17810                   break;
17811             }
17812          }
17813       }
17814    }
17815    if(ret != RFAILED)
17816    {
17817       duProcUeContextReleaseCommand(cellId, duUeCb);
17818    }
17819    freeAperDecodeUeContextReleaseCommand(f1apMsg);
17820    return ret;
17821 }
17822
17823 /**************************************************************
17824  *
17825  * @brief free the memory allocated by aper decoder for paging
17826  *
17827  * @details
17828  *
17829  *    Function : freeAperDecodePagingMsg
17830  *
17831  *    Functionality:
17832  *         - free the memory allocated by aper decoder for
17833  *         the paging f1ap msg
17834  *
17835  * @params[in] Paging_t   *paging
17836  * @return ROK     - success
17837  *         RFAILED - failure
17838  *
17839  ****************************************************************/
17840 void freeAperDecodePagingMsg(Paging_t   *paging)
17841 {
17842    uint8_t ieIdx, cellIdx;
17843    PagingCell_ItemIEs_t *pagingCellItemIes;
17844    PagingCell_Item_t *pagingCellItem;
17845    PagingCell_list_t  *pagingCelllist;
17846
17847    if(paging)
17848    {
17849       if(paging->protocolIEs.list.array)
17850       {
17851          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17852          {
17853             if(paging->protocolIEs.list.array[ieIdx])
17854             {
17855                switch(paging->protocolIEs.list.array[ieIdx]->id)
17856                {
17857                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17858                      {
17859                         free(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf);
17860                         break;
17861                      }
17862                   case ProtocolIE_ID_id_PagingIdentity:
17863                      {
17864                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
17865                         {
17866                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17867                            {
17868                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == \
17869                                     CNUEPagingIdentity_PR_fiveG_S_TMSI)
17870                               {
17871                                  free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf);
17872                               }
17873                               free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity);
17874                            }
17875                         }
17876                         break;
17877                      }
17878                   case ProtocolIE_ID_id_PagingCell_List:
17879                      {
17880                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17881                         if(pagingCelllist->list.array)
17882                         {
17883                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
17884                            {
17885                               if(pagingCelllist->list.array[cellIdx])
17886                               {
17887                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
17888                                  if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
17889                                  {
17890                                     pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17891                                     free(pagingCellItem->nRCGI.pLMN_Identity.buf);
17892                                     free(pagingCellItem->nRCGI.nRCellIdentity.buf);
17893                                  }
17894                                  free(pagingCelllist->list.array[cellIdx]);
17895                               }
17896                            }
17897                            free(pagingCelllist->list.array);
17898                         }
17899                         break;
17900                      }
17901                }
17902                free(paging->protocolIEs.list.array[ieIdx]);
17903             }
17904          }
17905          free(paging->protocolIEs.list.array);
17906
17907       }
17908    }
17909 }
17910
17911 /**************************************************************
17912  *
17913  * @brief processing the paging f1ap msg received from CU
17914  *
17915  * @details
17916  *
17917  *    Function : procPagingMsg
17918  *
17919  *    Functionality:
17920  *         - processing the paging f1ap msg received from CU
17921  *
17922  * @params[in] F1AP_PDU_t *f1apMsg
17923  * @return ROK     - success
17924  *         RFAILED - failure
17925  *
17926  *
17927  ****************************************************************/
17928 uint8_t procPagingMsg(F1AP_PDU_t *f1apMsg)
17929 {
17930    uint8_t ieIdx = 0, cellListIdx = 0;
17931    uint64_t cellId = 0;
17932    Paging_t   *paging = NULLP;
17933    PagingCell_list_t  *pagingCelllist = NULLP;
17934    PagingCell_ItemIEs_t *pagingCellItemIes = NULLP;
17935    PagingCell_Item_t *pagingCellItem = NULLP;
17936    DuPagingMsg *tmpPagingParam = NULLP;
17937
17938    paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
17939    if(paging)
17940    {
17941       if(paging->protocolIEs.list.array)
17942       {
17943          DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg));
17944          if(tmpPagingParam == NULLP)
17945          {
17946             DU_LOG("\nERROR  --> DU APP : Memory Allocation Failure in procPagingMsg");
17947             freeAperDecodePagingMsg(paging);
17948             return RFAILED;
17949          }
17950          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17951          {
17952             if(paging->protocolIEs.list.array[ieIdx])
17953             {
17954                switch(paging->protocolIEs.list.array[ieIdx]->id)
17955                {
17956                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17957                      {
17958                         bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10,\
17959                                          &tmpPagingParam->pagUeId);
17960                         break;
17961                      }
17962
17963                   case ProtocolIE_ID_id_PagingIdentity:
17964                      {
17965                         switch(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present)
17966                         {
17967                            case PagingIdentity_PR_cNUEPagingIdentity:
17968                               {
17969                                  if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17970                                  {
17971                                     bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.\
17972                                           cNUEPagingIdentity->choice.fiveG_S_TMSI, &tmpPagingParam->sTmsi);
17973
17974                                  }
17975                                  break;
17976                               }
17977                             case PagingIdentity_PR_rANUEPagingIdentity:
17978                                {
17979                                   /*TODO: This Identifier is specific to RAN Initiated Paging – Connected Mode Paging*/
17980                                   break;
17981                                }
17982                             default:
17983                                {
17984                                   DU_LOG("ERROR  -->  DU APP: Invalid UE Paging Identity, Skipping this Paging Message:");
17985                                   continue;
17986                                }
17987                         }
17988                      }
17989
17990                   case ProtocolIE_ID_id_PagingDRX:
17991                      {
17992                         tmpPagingParam->pagingDrxPres = TRUE;
17993                         tmpPagingParam->pagingDrx = convertPagingCycleEnumToValue(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX);
17994                         break;
17995                      }
17996
17997                   case ProtocolIE_ID_id_PagingPriority:
17998                      {
17999                         tmpPagingParam->pagPriority = paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority;
18000                         break;
18001                      }
18002
18003                   case ProtocolIE_ID_id_PagingCell_List:
18004                      {
18005                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
18006                         if(pagingCelllist->list.array)
18007                         {
18008                            for(cellListIdx = 0; cellListIdx < pagingCelllist->list.count; cellListIdx++)
18009                            {
18010                               if(pagingCelllist->list.array[cellListIdx])
18011                               {
18012                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellListIdx];
18013                                  pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
18014                                  bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId);
18015                                  if(processPagingMsg(cellId, tmpPagingParam) != ROK)
18016                                  {
18017                                     DU_LOG("\nERROR  --> DU APP : Paging Processing Failed at CellId:%lu",cellId);
18018                                     continue;
18019                                  }
18020                               }
18021                            }
18022                         }
18023                         break;
18024                      }
18025                    default:
18026                      {
18027                          DU_LOG("\nERROR  --> F1AP : Incorrect Paging IE option");
18028                          break;
18029                      }
18030                }
18031             }
18032          }
18033       }
18034    }
18035    DU_FREE(tmpPagingParam, sizeof(DuPagingMsg));
18036    freeAperDecodePagingMsg(paging);
18037
18038    return ROK;
18039 }
18040
18041 /**************************************************************
18042  *
18043  * @brief Handles received F1AP message and sends back response
18044  *
18045  * @details
18046  *
18047  *    Function : F1APMsgHdlr
18048  *
18049  *    Functionality:
18050  *         - Decodes received F1AP control message
18051  *         - Prepares response message, encodes and sends to SCTP
18052  *
18053  * @params[in]
18054  * @return ROK     - success
18055  *         RFAILED - failure
18056  *
18057  * ****************************************************************/
18058 void F1APMsgHdlr(Buffer *mBuf)
18059 {
18060    int i =0;
18061    char *recvBuf =NULLP;
18062    MsgLen copyCnt =0;
18063    MsgLen recvBufLen =0;
18064    F1AP_PDU_t *f1apMsg =NULLP;
18065    asn_dec_rval_t rval; /* Decoder return value */
18066    F1AP_PDU_t f1apasnmsg ;
18067    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
18068    ODU_PRINT_MSG(mBuf, 0,0);
18069
18070    /* Copy mBuf into char array to decode it */
18071    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
18072    DU_ALLOC(recvBuf, (Size)recvBufLen);
18073
18074    if(recvBuf == NULLP)
18075    {
18076       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
18077       return;
18078    }
18079    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
18080    {
18081       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
18082       return;
18083    }
18084
18085 #ifdef DEBUG_ASN_PRINT
18086    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
18087    for(i=0; i< recvBufLen; i++)
18088    {
18089       printf("%x",recvBuf[i]);
18090    }
18091 #endif
18092
18093    /* Decoding flat buffer into F1AP messsage */
18094    f1apMsg = &f1apasnmsg;
18095    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
18096
18097    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
18098
18099    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
18100    {
18101       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
18102       return;
18103    }
18104    printf("\n");
18105    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
18106
18107    switch(f1apMsg->present)
18108    {
18109       case F1AP_PDU_PR_successfulOutcome:
18110          {
18111             switch(f1apMsg->choice.successfulOutcome->value.present)
18112             {
18113                case SuccessfulOutcome__value_PR_ResetAcknowledge:
18114                   {
18115                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
18116                      break;
18117                   }
18118                case SuccessfulOutcome__value_PR_F1SetupResponse:
18119                   {
18120 #ifndef ODU_TEST_STUB
18121                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
18122 #endif
18123                      break;
18124                   }
18125
18126                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
18127                   {
18128                      procF1GNBDUCfgUpdAck(f1apMsg, recvBufLen, recvBuf);
18129                      break;
18130                   }
18131
18132                default:
18133                   {
18134                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
18135                            f1apMsg->choice.successfulOutcome->value.present);
18136                      return;
18137                   }
18138             }/* End of switch(successfulOutcome) */
18139             free(f1apMsg->choice.successfulOutcome);
18140             break;
18141          }
18142       case F1AP_PDU_PR_initiatingMessage:
18143          {
18144             switch(f1apMsg->choice.initiatingMessage->value.present)
18145             {
18146                case InitiatingMessage__value_PR_Reset:
18147                   {
18148                      procF1ResetReq(f1apMsg);
18149                      break;
18150                   }
18151                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
18152                   {
18153                      procF1DlRrcMsgTrans(f1apMsg);
18154                      break;
18155                   }
18156                case InitiatingMessage__value_PR_UEContextSetupRequest:
18157                   {
18158                      procF1UeContextSetupReq(f1apMsg);
18159                      break;
18160                   }
18161                case InitiatingMessage__value_PR_UEContextModificationRequest:
18162                   {
18163                      procF1UeContextModificationReq(f1apMsg);
18164                      break;
18165                   }
18166                case InitiatingMessage__value_PR_UEContextReleaseCommand:
18167                   {
18168                       procF1UeContextReleaseCommand(f1apMsg);
18169                       break;
18170                   }
18171                case InitiatingMessage__value_PR_Paging:
18172                   {
18173                      procPagingMsg(f1apMsg);
18174                      break;
18175                   }
18176                default:
18177                   {
18178                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
18179                            f1apMsg->choice.initiatingMessage->value.present);
18180                      return;
18181                   }
18182             }/* End of switch(initiatingMessage) */
18183             free(f1apMsg->choice.initiatingMessage);
18184             break;
18185          }
18186
18187       default:
18188          {
18189             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
18190             return;
18191          }
18192          free(f1apMsg);
18193
18194    }/* End of switch(f1apMsg->present) */
18195
18196    DU_FREE(recvBuf, (Size)recvBufLen);
18197 } /* End of F1APMsgHdlr */
18198
18199 /**********************************************************************
18200   End of file
18201  **********************************************************************/