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 "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "du_app_mac_inf.h"
  26 #include "du_cfg.h"
  27 #include "du_app_rlc_inf.h"
  28 #include "du_mgr_main.h"
  29 #include "du_utils.h"
  30 #include "RAT-Type.h"
  31 #include "FeatureSetUplinkPerCC.h"
  32 #include "FeatureSetDownlinkPerCC.h"
  33 #include "FeatureSets.h"
  34 #include "UE-NR-Capability.h"
  35 #include "UE-CapabilityRAT-Container.h"
  36 #include "UE-CapabilityRAT-ContainerListRRC.h"
  37 #include "GNB-DU-System-Information.h"
  38 #include "CellGroupConfigRrc.h"
  39 #include "MAC-CellGroupConfig.h"
  40 #include "SchedulingRequestConfig.h"
  41 #include "SchedulingRequestToAddMod.h"
  42 #include "BSR-Config.h"
  43 #include "TAG-Config.h"
  44 #include "TAG.h"
  45 #include "PHR-Config.h"
  46 #include "RLC-Config.h"
  47 #include "UL-AM-RLC.h"
  48 #include "DL-AM-RLC.h"
  49 #include "LogicalChannelConfig.h"
  50 #include "RLC-BearerConfig.h"
  51 #include "PhysicalCellGroupConfig.h"
  52 #include "SpCellConfig.h"
  53 #include "TDD-UL-DL-ConfigDedicated.h"
  54 #include "ServingCellConfig.h"
  55 #include "ControlResourceSet.h"
  56 #include "SearchSpace.h"
  57 #include "PDCCH-Config.h"
  58 #include "PDSCH-TimeDomainResourceAllocation.h"
  59 #include "PDSCH-TimeDomainResourceAllocationList.h"
  60 #include "PDSCH-CodeBlockGroupTransmission.h"
  61 #include "PDSCH-ServingCellConfig.h"
  62 #include "DMRS-DownlinkConfig.h"
  63 #include "PDSCH-Config.h"
  64 #include "BWP-DownlinkDedicated.h"
  65 #include "PUSCH-TimeDomainResourceAllocation.h"
  66 #include "PUSCH-TimeDomainResourceAllocationList.h"
  67 #include "DMRS-UplinkConfig.h"
  68 #include "PUSCH-Config.h"
  69 #include "SRS-ResourceId.h"
  70 #include "SRS-Resource.h"
  71 #include "SRS-ResourceSet.h"
  72 #include "SRS-Config.h"
  73 #include "BWP-UplinkDedicated.h"
  74 #include "PUSCH-ServingCellConfig.h"
  75 #include "UplinkConfig.h"
  76 #include "DUtoCURRCContainer.h"
  77 #include "GBR-QoSFlowInformation.h"
  78 #include "QoSFlowLevelQoSParameters.h"
  79 #include "PUCCH-Config.h"
  80 #include "PUCCH-ResourceSet.h"
  81 #include "PUCCH-Resource.h"
  82 #include "PUCCH-PowerControl.h"
  83 #include "P0-PUCCH.h"
  84 #include "PUCCH-PathlossReferenceRS.h"
  85 #include "PUCCH-format0.h"
  86 #include "PUCCH-format1.h"
  87 #include "PUCCH-format2.h"
  88 #include "PUCCH-format3.h"
  89 #include "PUCCH-format4.h"
  90 #include "PUCCH-FormatConfig.h"
  91 #include "SchedulingRequestResourceConfig.h"
  92 #include<ProtocolIE-Field.h>
  93 #include "ProtocolExtensionField.h"
  94 #include "F1AP-PDU.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99
 100 DuCfgParams duCfgParam;
 101
 102 /*******************************************************************
 103  *
 104  * @brief Builds Uplink Info for NR
 105  *
 106  * @details
 107  *
 108  *    Function : BuildULNRInfo
 109  *
 110  *    Functionality: Building NR Uplink Info
 111  *
 112  * @params[in] NRFreqInfo_t *ulnrfreq
 113  * @return ROK     - success
 114  *         RFAILED - failure
 115  *
 116  * ****************************************************************/
 117 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 118 {
 119    uint8_t idx=0;
 120    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 121                        fdd.ulNrFreqInfo.nrArfcn;
 122    ulnrfreq->freqBandListNr.list.count = 1;
 123    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 124    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 125    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 126    {
 127       return RFAILED;
 128    }
 129    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 130    {
 131       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 132       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 133       {
 134          return RFAILED;
 135       }
 136    }
 137    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 138                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 139                                                                  freqBand[0].nrFreqBand;
 140    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 141    return ROK;
 142 }
 143 /*******************************************************************
 144  *
 145  * @brief Builds Downlink NR Info
 146  *
 147  * @details
 148  *
 149  *    Function : BuildDLNRInfo
 150  *
 151  *    Functionality: Building Downlink NR Info
 152  *
 153  * @params[in] NRFreqInfo_t *dlnrfreq
 154  * @return ROK     - success
 155  *         RFAILED - failure
 156  *
 157  * ****************************************************************/
 158 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 159 {
 160    uint8_t idx=0;
 161    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 162                        fdd.dlNrFreqInfo.nrArfcn;
 163    dlnrfreq->freqBandListNr.list.count = 1;
 164    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 165    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 166    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 167    {
 168       return RFAILED;
 169    }
 170    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 171    {
 172       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 173       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 174       {
 175          return RFAILED;
 176       }
 177    }
 178    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 179                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 180                                                                  freqBand[0].nrFreqBand;
 181    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 182
 183    return ROK;
 184 }
 185
 186 /*******************************************************************
 187  *
 188  * @brief Builds NRCell ID
 189  *
 190  * @details
 191  *
 192  *    Function : BuildNrCellId
 193  *
 194  *    Functionality: Building the NR Cell ID
 195  *
 196  * @params[in] BIT_STRING_t *nrcell
 197  * @return ROK     - success
 198  *         RFAILED - failure
 199  *
 200  * ****************************************************************/
 201
 202 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 203 {
 204    memset(nrcell->buf, 0, nrcell->size);
 205    nrcell->buf[4]   = 16;
 206    nrcell->bits_unused = 4;
 207    return ROK;
 208 }
 209
 210 /*******************************************************************
 211  *
 212  * @brief Builds Nrcgi
 213  *
 214  * @details
 215  *
 216  *    Function : BuildNrcgi
 217  *
 218  *    Functionality: Building the PLMN ID and NR Cell id
 219  *
 220  * @params[in] NRCGI_t *nrcgi
 221  * @return ROK     - success
 222  *         RFAILED - failure
 223  *
 224  * ****************************************************************/
 225 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 226 {
 227    uint8_t ret;
 228    uint8_t byteSize = 5;
 229    /* Allocate Buffer Memory */
 230    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 231    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 232    if(nrcgi->pLMN_Identity.buf == NULLP)
 233    {
 234       return RFAILED;
 235    }
 236    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 237          nrcgi->pLMN_Identity.buf); // Building PLMN function
 238    if(ret != ROK)
 239    {
 240       return RFAILED;
 241    }
 242    /*nrCellIdentity*/
 243    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 244    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 245    if(nrcgi->nRCellIdentity.buf == NULLP)
 246    {
 247       return RFAILED;
 248    }
 249    BuildNrCellId(&nrcgi->nRCellIdentity);
 250
 251    return ROK;
 252 }
 253 /*******************************************************************
 254  *
 255  * @brief Builds FiveGStac
 256  *
 257  * @details
 258  *
 259  *    Function : BuildFiveGSTac
 260  *
 261  *    Functionality: Building the FiveGSTac
 262  *
 263  * @params[in] OCTET_STRING_t *fivegsTac
 264  * @return ROK     - success
 265  *         RFAILED - failure
 266  *
 267  * ****************************************************************/
 268 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 269 {
 270    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 271    if(servcell->fiveGS_TAC == NULLP)
 272    {
 273       return RFAILED;
 274    }
 275    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 276    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 277          sizeof(servcell->fiveGS_TAC->size));
 278    if(servcell->fiveGS_TAC->buf == NULLP)
 279    {
 280       return RFAILED;
 281    }
 282    servcell->fiveGS_TAC->buf[0] = 0;
 283    servcell->fiveGS_TAC->buf[1] = 0;
 284    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 285    return ROK;
 286 }
 287 /*******************************************************************
 288  *
 289  * @brief Builds NR Mode
 290  *
 291  * @details
 292  *
 293  *    Function : BuildNrMode
 294  *
 295  *    Functionality: Building the NR Mode
 296  *
 297  * @params[in] NR_Mode_Info_t *fdd
 298  * @return ROK     - success
 299  *         RFAILED - failure
 300  *
 301  * ****************************************************************/
 302 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 303 {
 304    uint8_t BuildDLNRInforet=0;
 305    uint8_t BuildULNRInforet=0;
 306    /* FDD Mode */
 307    mode->present = NR_Mode_Info_PR_fDD;
 308    if(mode->present == NR_Mode_Info_PR_fDD)
 309    {
 310       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 311       if(mode->choice.fDD == NULLP)
 312       {
 313          return RFAILED;
 314       }
 315       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 316       if(BuildULNRInforet != ROK)
 317       {
 318          return RFAILED;
 319       }
 320       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 321       if(BuildDLNRInforet != ROK)
 322       {
 323          return RFAILED;
 324       }
 325    }
 326    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 327                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 328                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 329    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 330                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 331                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 332    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 333                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 334                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 335    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 336                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 337                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 338    return ROK;
 339 }
 340 /*******************************************************************
 341  *
 342  * @brief Builds IE Extensions for Served PLMNs
 343  *
 344  * @details
 345  *
 346  *    Function : BuildExtensions
 347  *
 348  *    Functionality: Building the IE Extensions
 349  *
 350  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 351  * @return ROK     - success
 352  *         RFAILED - failure
 353  *
 354  * ****************************************************************/
 355 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 356 {
 357    uint8_t idx;
 358    uint8_t plmnidx;
 359    uint8_t extensionCnt=1;
 360    uint8_t sliceId=0;
 361    uint8_t sdId;
 362    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 363    if((*ieExtend) == NULLP)
 364    {
 365       return RFAILED;
 366    }
 367    (*ieExtend)->list.count = extensionCnt;
 368    (*ieExtend)->list.size = \
 369                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 370    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 371    if((*ieExtend)->list.array == NULLP)
 372    {
 373       return RFAILED;
 374    }
 375    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 376    {
 377       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 378             sizeof(ServedPLMNs_ItemExtIEs_t));
 379       if((*ieExtend)->list.array[plmnidx] == NULLP)
 380       {
 381          return RFAILED;
 382       }
 383    }
 384    idx = 0;
 385    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 386    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 387    (*ieExtend)->list.array[idx]->extensionValue.present = \
 388                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 389    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 390       list.count = 1;
 391    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 392       list.size = sizeof(SliceSupportItem_t *);
 393    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 394          list.array,sizeof(SliceSupportItem_t *));
 395    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 396          list.array == NULLP)
 397    {
 398       return RFAILED;
 399    }
 400    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 401          list.array[sliceId],sizeof(SliceSupportItem_t));
 402    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 403          list.array[sliceId] == NULLP)
 404    {
 405       return RFAILED;
 406    }
 407    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 408       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
 409    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 410          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 411          extensionValue.choice.SliceSupportList.\
 412          list.array[sliceId]->sNSSAI.sST.size);
 413    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 414          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
 415    {
 416       return RFAILED;
 417    }
 418    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 419       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
 420    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 421          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 422    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 423          list.array[sliceId]->sNSSAI.sD == NULLP)
 424    {
 425       return RFAILED;
 426    }
 427    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 428       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
 429    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 430          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
 431          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 432    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 433          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
 434    {
 435       return RFAILED;
 436    }
 437    sdId = 0;
 438    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 439       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
 440    sdId++;
 441    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 442       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
 443    sdId++;
 444    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 445       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
 446    return ROK;
 447 }
 448 /*******************************************************************
 449  *
 450  * @brief Builds Served PLMN
 451  *
 452  * @details
 453  *
 454  *    Function : BuildServedPlmn
 455  *
 456  *    Functionality: Building the Served PLMN
 457  *
 458  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 459  * @return ROK     - success
 460  *         RFAILED - failure
 461  *
 462  * ****************************************************************/
 463 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 464 {
 465    uint8_t  plmnidx;
 466    uint8_t  servPlmnCnt=1;
 467    uint8_t buildPlmnIdret=0;
 468    uint8_t BuildExtensionsret=0;
 469    srvplmn->list.count = servPlmnCnt;
 470    srvplmn->list.size = \
 471                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 472    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 473    if(srvplmn->list.array == NULLP)
 474    {
 475       return RFAILED;
 476    }
 477    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 478    {
 479       DU_ALLOC(srvplmn->list.array[plmnidx],\
 480             sizeof(ServedPLMNs_Item_t));
 481       if(srvplmn->list.array[plmnidx] == NULLP)
 482       {
 483          return RFAILED;
 484       }
 485    }
 486    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 487    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 488    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 489          srvplmn->list.array[0]->pLMN_Identity.buf);
 490    if(buildPlmnIdret!= ROK)
 491    {
 492       return RFAILED;
 493    }
 494    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 495    if(BuildExtensionsret!= ROK)
 496    {
 497       return RFAILED;
 498    }
 499    return ROK;
 500 }
 501 /*******************************************************************
 502  *
 503  * @brief Builds Served Cell List
 504  *
 505  * @details
 506  *
 507  *    Function : BuildServedCellList
 508  *
 509  *    Functionality: Building Served Cell List
 510  *
 511  * @params[in] PLMNID plmn
 512  * @return ROK     - success
 513  *         RFAILED - failure
 514  *
 515  * ****************************************************************/
 516
 517 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 518 {
 519    uint8_t  BuildNrcgiret=0;
 520    uint8_t  BuildFiveGSTacret=0;
 521    uint8_t  BuildServedPlmnret=0;
 522    uint8_t  BuildNrModeret=0;
 523    uint8_t  idx;
 524    uint8_t  plmnidx;
 525    uint8_t  plmnCnt=1;
 526    GNB_DU_Served_Cells_Item_t *srvCellItem;
 527    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 528    duServedCell->list.count = plmnCnt;
 529
 530    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
 531    if(duServedCell->list.array == NULLP)
 532    {
 533       return RFAILED;
 534    }
 535    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 536    {
 537       DU_ALLOC(duServedCell->list.array[plmnidx],\
 538             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 539       if(duServedCell->list.array[plmnidx] == NULLP)
 540       {
 541          return RFAILED;
 542       }
 543    }
 544    idx = 0;
 545    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 546    duServedCell->list.array[idx]->criticality = Criticality_reject;
 547    duServedCell->list.array[idx]->value.present = \
 548                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 549    srvCellItem = \
 550                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 551    /*nRCGI*/
 552    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 553    if(BuildNrcgiret != ROK)
 554    {
 555       return RFAILED;
 556    }
 557    /*nRPCI*/
 558    srvCellItem->served_Cell_Information.nRPCI = \
 559                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 560
 561    /*fiveGS_TAC*/
 562    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 563    if(BuildFiveGSTacret != ROK)
 564    {
 565       return RFAILED;
 566    }
 567    /*Served PLMNs*/
 568    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 569    if(BuildServedPlmnret !=ROK)
 570    {
 571       return RFAILED;
 572    }
 573    /*nR Mode Info with FDD*/
 574    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 575    if(BuildNrModeret != ROK)
 576    {
 577       return RFAILED;
 578    }
 579    /*Measurement timing Config*/
 580    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 581       size = sizeof(uint8_t);
 582    DU_ALLOC(srvCellItem->served_Cell_Information.\
 583          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 584    if(srvCellItem->served_Cell_Information.\
 585          measurementTimingConfiguration.buf == NULLP)
 586    {
 587       return RFAILED;
 588    }
 589    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 590                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 591
 592    /* GNB DU System Information */
 593    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 594          sizeof(GNB_DU_System_Information_t));
 595    if(!srvCellItem->gNB_DU_System_Information)
 596    {
 597       return RFAILED;
 598    }
 599    /* MIB */
 600    srvCellItem->gNB_DU_System_Information->mIB_message.size =\
 601                                                              strlen(( char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
 602    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 603          srvCellItem->gNB_DU_System_Information->mIB_message.size);
 604    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 605    {
 606       return RFAILED;
 607    }
 608    strcpy((char *)srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 609          (char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
 610
 611    /* SIB1 */
 612    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 613                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 614
 615    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 616          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 617    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 618    {
 619       return RFAILED;
 620    }
 621    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 622    {
 623       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 624                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 625    }
 626    return ROK;
 627 }
 628 /*******************************************************************
 629  *
 630  * @brief Builds RRC Version
 631  *
 632  * @details
 633  *
 634  *    Function : BuildRrcVer
 635  *
 636  *    Functionality: Building RRC Version
 637  *
 638  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 639  * @return ROK     - success
 640  *         RFAILED - failure
 641  *
 642  * ****************************************************************/
 643 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
 644 {
 645    uint8_t rrcExt;
 646    uint8_t rrcLatest;
 647    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
 648    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
 649    if(rrcVer->latest_RRC_Version.buf == NULLP)
 650    {
 651       return RFAILED;
 652    }
 653    rrcVer->latest_RRC_Version.buf[0] = 0;
 654    rrcVer->latest_RRC_Version.bits_unused = 5;
 655    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 656    if(rrcVer->iE_Extensions == NULLP)
 657    {
 658       return RFAILED;
 659    }
 660    rrcVer->iE_Extensions->list.count = 1;
 661    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
 662    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
 663    if(rrcVer->iE_Extensions->list.array == NULLP)
 664    {
 665       return RFAILED;
 666    }
 667    rrcExt = 0;
 668    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 669          sizeof(RRC_Version_ExtIEs_t));
 670    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 671    {
 672       return RFAILED;
 673    }
 674    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
 675                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 676    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
 677    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
 678                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 679    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 680       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 681    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 682          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 683          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 684    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 685          .Latest_RRC_Version_Enhanced.buf == NULLP)
 686    {
 687       return RFAILED;
 688    }
 689    rrcLatest = 0;
 690    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 691       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
 692    rrcLatest++;
 693    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 694       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
 695    rrcLatest++;
 696    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 697       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
 698    return ROK;
 699 }
 700 /*******************************************************************
 701  *
 702  * @brief Sends F1 msg over SCTP
 703  *
 704  * @details
 705  *
 706  *    Function : SendF1APMsg
 707  *
 708  *    Functionality: Sends F1 msg over SCTP
 709  *
 710  * @params[in] Region region
 711  *             Pool pool
 712  * @return ROK     - success
 713  *         RFAILED - failure
 714  *
 715  * ****************************************************************/
 716 uint8_t SendF1APMsg(Region region, Pool pool)
 717 {
 718    Buffer *mBuf = NULLP;
 719
 720    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 721    {
 722       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 723       {
 724             ODU_PRINT_MSG(mBuf, 0,0);
 725
 726             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
 727             {
 728                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 729                ODU_PUT_MSG_BUF(mBuf);
 730                return RFAILED;
 731             }
 732       }
 733       else
 734       {
 735          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 736          ODU_PUT_MSG_BUF(mBuf);
 737          return RFAILED;
 738       }
 739       ODU_PUT_MSG_BUF(mBuf);
 740    }
 741    else
 742    {
 743       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 744       return RFAILED;
 745    }
 746    return ROK;
 747 } /* SendF1APMsg */
 748
 749 /*******************************************************************
 750  *
 751  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
 752  *
 753  * @details
 754  *
 755  *    Function :  FreeRrcVer
 756  *
 757  *    Functionality: deallocating the memory of function BuildRrcVer
 758  *
 759  * @params[in] RRC_Version_t *rrcVer
 760  *
 761  * @return void
 762  *
 763  *****************************************************************/
 764 void FreeRrcVer(RRC_Version_t *rrcVer)
 765 {
 766    if(rrcVer->latest_RRC_Version.buf != NULLP)
 767    {
 768       if(rrcVer->iE_Extensions != NULLP)
 769       {
 770          if(rrcVer->iE_Extensions->list.array != NULLP)
 771          {
 772             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
 773             {
 774                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
 775                      != NULLP)
 776                {
 777                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
 778                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 779                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 780                }
 781                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
 782             }
 783             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
 784          }
 785          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 786       }
 787       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
 788    }
 789 }
 790 /*******************************************************************
 791  *
 792  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
 793  *
 794  * @details
 795  *
 796  *    Function :  FreeServedCellList
 797  *
 798  *    Functionality:  deallocating the memory of function BuildServedCellList
 799
 800  *
 801  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
 802  *
 803  * @return void
 804  *
 805  * ****************************************************************/
 806 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
 807 {
 808    uint8_t   plmnCnt=1;
 809    uint8_t  servId=0;
 810    uint8_t sliceId=0;
 811    uint8_t  ieId=0;
 812    uint8_t   extensionCnt=1;
 813    uint8_t plmnidx=0;
 814    GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
 815    if(duServedCell->list.array!=NULLP)
 816    {
 817       if(duServedCell->list.array[0]!=NULLP)
 818       {
 819          if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
 820          {
 821             if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
 822             {
 823                if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
 824                {
 825                   if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
 826                   {
 827                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
 828                      {
 829                         if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
 830                         {
 831                            if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
 832                            {
 833                               if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
 834                               {
 835                                  if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
 836                                  {
 837                                     if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
 838                                     {
 839                                        if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 840                                              extensionValue.choice.SliceSupportList.list.array!=NULLP)
 841                                        {
 842                                           if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 843                                                 extensionValue.choice.SliceSupportList.list.array[sliceId]!= NULLP)
 844                                           {
 845                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 846                                                    extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.buf!=NULLP)
 847                                              {
 848                                                 if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 849                                                       extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
 850                                                 {
 851                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
 852                                                          list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
 853                                                    {
 854                                                       if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
 855                                                       {
 856                                                          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
 857                                                                freqBandListNr.list.array!=NULLP)
 858                                                          {
 859                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
 860                                                                   freqBandListNr.list.array[0]!=NULLP)
 861                                                             {
 862                                                                if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 863                                                                      freqBandListNr.list.array)
 864                                                                {
 865                                                                   if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 866                                                                         freqBandListNr.list.array[0]!=NULLP)
 867                                                                   {
 868                                                                      if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
 869                                                                      {
 870                                                                         if(!srvCellItem->gNB_DU_System_Information)
 871                                                                         {
 872                                                                            if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
 873                                                                            {
 874                                                                               if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
 875                                                                               {
 876                                                                                  DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
 877                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 878                                                                                  DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
 879                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 880                                                                               }
 881                                                                               DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
 882                                                                                     srvCellItem->gNB_DU_System_Information->mIB_message.size);
 883                                                                               DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
 884                                                                                     strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
 885                                                                            }
 886                                                                            DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
 887                                                                         }
 888                                                                         DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
 889                                                                               srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 890                                                                      }
 891                                                                      DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 892                                                                            freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
 893                                                                   }
 894                                                                   DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 895                                                                         freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
 896                                                                }
 897                                                                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
 898                                                                      list.array[0],sizeof(FreqBandNrItem_t));
 899                                                             }
 900                                                             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
 901                                                                   list.array,sizeof(FreqBandNrItem_t*));
 902                                                          }
 903                                                          DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
 904                                                       }
 905                                                       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 906                                                             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
 907                                                             sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
 908                                                             list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 909                                                    }
 910                                                    DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 911                                                          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 912                                                          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 913                                                 }
 914                                                 DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 915                                                       iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
 916                                                       sNSSAI.sST.buf,sizeof(uint8_t));
 917                                              }
 918                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 919                                                    extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
 920                                           }
 921                                           DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 922                                                 extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
 923                                        }
 924                                        DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 925                                              array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
 926                                     }
 927                                     DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 928                                           array[servId]->iE_Extensions->list.array,\
 929                                           extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
 930                                  }
 931                                  DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 932                                        array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
 933                               }
 934                               DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 935                                     array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
 936                                     servedPLMNs.list.array[servId]->pLMN_Identity.size
 937                                     * sizeof(uint8_t));
 938                            }
 939                            DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
 940                                  sizeof(ServedPLMNs_Item_t *));
 941                         }
 942                         DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
 943                               sizeof(ServedPLMNs_Item_t *));
 944                      }
 945                      DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
 946                            sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
 947                   }
 948                   DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
 949                }
 950                DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
 951                      srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
 952                      sizeof(uint8_t));
 953             }
 954             DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
 955                   srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
 956                   sizeof(uint8_t));
 957          }
 958          DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 959       }
 960       DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
 961    }
 962 }
 963 /*******************************************************************
 964  *
 965  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
 966  *
 967  * @details
 968  *
 969  *    Function :  FreeF1SetupReq
 970  *
 971  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
 972  *
 973  * @params[in] F1AP_PDU_t *f1apMsg
 974  *
 975  * @return void
 976  *
 977  * ****************************************************************/
 978 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
 979 {
 980    uint8_t ieIdx, ieIdx2;
 981    F1SetupRequest_t *f1SetupReq=NULLP;
 982
 983    if(f1apMsg != NULLP)
 984    {
 985       if(f1apMsg->choice.initiatingMessage != NULLP)
 986       {
 987          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
 988          if(f1SetupReq->protocolIEs.list.array != NULLP)
 989          {
 990             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
 991             {
 992                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
 993                {
 994                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
 995                   {
 996                      case ProtocolIE_ID_id_TransactionID:
 997                         break;
 998                      case ProtocolIE_ID_id_gNB_DU_ID:
 999                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1000                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1001                         break;
1002                      case ProtocolIE_ID_id_gNB_DU_Name:
1003                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1004                               strlen((char *)duCfgParam.duName));
1005                         break;
1006                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1007                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1008                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1009                         break;
1010                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1011                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1012                         break;
1013                      default:
1014                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1015                         break;
1016                   }
1017                }
1018                break;
1019             }
1020             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1021             {
1022                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1023             }
1024             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1025                   f1SetupReq->protocolIEs.list.size);
1026          }
1027          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1028       }
1029       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1030    }
1031 }
1032 /*******************************************************************
1033  *
1034  * @brief Builds and Send the F1SetupRequest
1035  *
1036  * @details
1037  *
1038  *    Function : BuildAndSendF1SetupReq
1039  *
1040  * Functionality:Fills the F1SetupRequest
1041  *
1042  * @return ROK     - success
1043  *         RFAILED - failure
1044  *
1045  ******************************************************************/
1046 uint8_t BuildAndSendF1SetupReq()
1047 {
1048    uint8_t   ret, ieIdx, elementCnt;
1049    F1AP_PDU_t                 *f1apMsg = NULLP;
1050    F1SetupRequest_t           *f1SetupReq=NULLP;
1051    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1052    RRC_Version_t              *rrcVer=NULLP;
1053    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1054    ret= RFAILED;
1055
1056    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1057    do
1058    {
1059       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1060       if(f1apMsg == NULLP)
1061       {
1062          break;
1063       }
1064       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1065       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1066       if(f1apMsg->choice.initiatingMessage == NULLP)
1067       {
1068          break;
1069       }
1070       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1071       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1072       f1apMsg->choice.initiatingMessage->value.present = \
1073                                                          InitiatingMessage__value_PR_F1SetupRequest;
1074
1075       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1076
1077       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1078
1079       f1SetupReq->protocolIEs.list.count = elementCnt;
1080       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1081
1082       /* Initialize the F1Setup members */
1083       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1084       if(f1SetupReq->protocolIEs.list.array == NULLP)
1085       {
1086          break;
1087       }
1088       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1089       {
1090          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1091                sizeof(F1SetupRequestIEs_t));
1092          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1093          {
1094             break;
1095          }
1096       }
1097
1098       ieIdx = 0;
1099       /*TransactionID*/
1100       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1101       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1102       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1103                                                                F1SetupRequestIEs__value_PR_TransactionID;
1104       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1105                                                                              TRANS_ID;
1106
1107       /*DU ID*/
1108       ieIdx++;
1109       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1110       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1111       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1112                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1113       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1114                                                                              sizeof(uint8_t);
1115
1116       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1117             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1118       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1119             NULLP)
1120       {
1121          break;
1122       }
1123
1124       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1125          duCfgParam.duId;
1126
1127       /*DU Name*/
1128       if(duCfgParam.duName != NULL)
1129       {
1130          ieIdx++;
1131          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1132          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1133          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1134          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1135             strlen((char *)duCfgParam.duName);
1136          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1137                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1138          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1139                buf == NULLP)
1140          {
1141             break;
1142          }
1143          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1144                choice.GNB_DU_Name.buf,
1145                (char*)&duCfgParam.duName);
1146
1147       }
1148
1149       /*Served Cell list */
1150       ieIdx++;
1151       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1152                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1153       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1154       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1155                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1156       duServedCell = &f1SetupReq->protocolIEs.list.\
1157                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1158       if(BuildServedCellList(duServedCell))
1159       {
1160          break;
1161       }
1162       /*RRC Version*/
1163       ieIdx++;
1164       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1165                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1166       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1167       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1168                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1169       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1170       if(BuildRrcVer(rrcVer))
1171       {
1172          break;
1173       }
1174       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1175
1176       /* Encode the F1SetupRequest type as APER */
1177       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1178       encBufSize = 0;
1179       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1180             encBuf);
1181
1182       /* Encode results */
1183       if(encRetVal.encoded == ENCODE_FAIL)
1184       {
1185          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1186                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1187          break;
1188       }
1189       else
1190       {
1191          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1192          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1193          {
1194             printf("%x",encBuf[ieIdx]);
1195          }
1196       }
1197
1198       /* Sending msg */
1199       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1200       {
1201          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1202          break;
1203       }
1204
1205       ret=ROK;
1206       break;
1207    }while(true);
1208
1209    FreeF1SetupReq(f1apMsg);
1210
1211    return ret;
1212 }/* End of BuildAndSendF1SetupReq */
1213
1214 /*******************************************************************
1215  *
1216  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1217  *
1218  * @details
1219  *
1220  *    Function : FreeDUConfigUpdate
1221  *
1222  *    Functionality: Deallocating memory of variables allocated in
1223  *                    BuildAndSendDUConfigUpdate function
1224  *
1225  * @params[in]  F1AP_PDU_t *f1apDuCfg
1226  *
1227  * @return ROK     - void
1228  *
1229  * ****************************************************************/
1230 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1231 {
1232    uint8_t  i;
1233    uint8_t  idx;
1234    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1235    Served_Cells_To_Modify_List_t  *cellsToModify;
1236    Served_Cells_To_Modify_Item_t *modifyItem;
1237    idx=0;
1238    i=1;
1239    if(f1apDuCfg != NULLP)
1240    {
1241       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1242       {
1243          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1244                        value.choice.GNBDUConfigurationUpdate;
1245          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1246          {
1247             if(duCfgUpdate->protocolIEs.list.array[i] != NULLP)
1248             {
1249                cellsToModify = &duCfgUpdate->protocolIEs.list.array[i]->\
1250                                value.choice.Served_Cells_To_Modify_List;
1251                if(cellsToModify->list.array != NULLP)
1252                {
1253                   if(cellsToModify->list.array[idx] != NULLP)
1254                   {
1255                      modifyItem=&cellsToModify->list.array[idx]->value.choice.\
1256                                 Served_Cells_To_Modify_Item;
1257                      if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
1258                      {
1259                         if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
1260                         {
1261                            if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
1262                            {
1263                               if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
1264                                     != NULLP)
1265                               {
1266                                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
1267                                        != NULLP)
1268                                  {
1269                                     if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[idx])
1270                                     {
1271                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1272                                              array[idx]->pLMN_Identity.buf != NULLP)
1273                                        {
1274                                           if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1275                                                 array[idx]->iE_Extensions!= NULLP)
1276                                           {
1277                                              if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1278                                                    array[idx]->iE_Extensions->list.array != NULLP)
1279                                              {
1280                                                 if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1281                                                       array[idx]->iE_Extensions->list.array[idx])
1282                                                 {
1283                                                    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1284                                                          iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1285                                                          list.array !=NULLP)
1286                                                    {
1287                                                       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1288                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1289                                                             list.array[idx]!=NULLP)
1290                                                       {
1291                                                          if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1292                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1293                                                                list.array[idx]->sNSSAI.sST.buf!=NULLP)
1294                                                          {
1295                                                             if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1296                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1297                                                                   list.array[idx]->sNSSAI.sD != NULLP)
1298                                                             {
1299                                                                if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1300                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1301                                                                      list.array[idx]->sNSSAI.sD->buf!=NULLP)
1302                                                                {
1303                                                                   if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
1304                                                                         !=NULLP)
1305                                                                   {
1306                                                                      if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1307                                                                            fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
1308                                                                      {
1309                                                                         if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1310                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.array[idx]!=NULLP)
1311                                                                         {
1312                                                                            if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1313                                                                                  fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
1314                                                                            {
1315                                                                               if(modifyItem->served_Cell_Information.nR_Mode_Info.\
1316                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1317                                                                                     array[idx]!= NULLP)
1318                                                                               {
1319                                                                                  if(modifyItem->served_Cell_Information.\
1320                                                                                        measurementTimingConfiguration.buf !=NULLP)
1321                                                                                  {
1322                                                                                     idx=2;
1323                                                                                     if(duCfgUpdate->protocolIEs.list.array[idx]->value.\
1324                                                                                           choice.GNB_DU_ID.buf!=NULLP)
1325                                                                                     {
1326                                                                                        DU_FREE(duCfgUpdate->protocolIEs.list.\
1327                                                                                              array[idx]->value.choice.GNB_DU_ID.buf,\
1328                                                                                              duCfgUpdate->protocolIEs.list.array[idx]->\
1329                                                                                              value.choice.GNB_DU_ID.size);
1330                                                                                     }
1331                                                                                     idx=0;
1332                                                                                     DU_FREE(modifyItem->served_Cell_Information.\
1333                                                                                           measurementTimingConfiguration.\
1334                                                                                           buf,modifyItem->served_Cell_Information.\
1335                                                                                           measurementTimingConfiguration.size);
1336                                                                                  }
1337                                                                                  DU_FREE(modifyItem->served_Cell_Information.\
1338                                                                                        nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.\
1339                                                                                        list.array[idx],sizeof(FreqBandNrItem_t));
1340                                                                               }
1341                                                                               DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
1342                                                                                     .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1343                                                                                     modifyItem->served_Cell_Information.nR_Mode_Info.\
1344                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1345                                                                            }
1346                                                                            DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1347                                                                                  choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1348                                                                                  array[idx],sizeof(FreqBandNrItem_t));
1349                                                                         }
1350                                                                         DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1351                                                                               choice.\
1352                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.\
1353                                                                               array,modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1354                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1355                                                                      }
1356                                                                      DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1357                                                                            fDD,sizeof(FDD_Info_t));
1358                                                                   }
1359                                                                   DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1360                                                                         array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1361                                                                         SliceSupportList.\
1362                                                                         list.array[idx]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.\
1363                                                                         servedPLMNs.list.array[idx]->iE_Extensions->list.array[idx]->\
1364                                                                         extensionValue.choice.SliceSupportList.list.array[idx]->\
1365                                                                         sNSSAI.sD->size);
1366
1367                                                                }
1368                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1369                                                                      array[idx]->\
1370                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1371                                                                      list.array[idx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1372                                                             }
1373                                                             DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1374                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1375                                                                   list.array[idx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
1376                                                                   servedPLMNs.\
1377                                                                   list.array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1378                                                                   SliceSupportList.list.array[idx]->sNSSAI.sST.size);
1379                                                          }
1380                                                          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1381                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1382                                                                list.array[idx],sizeof(SliceSupportItem_t));
1383                                                       }
1384                                                       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1385                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1386                                                             list.array,\
1387                                                             modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1388                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.list.size);
1389                                                    }
1390                                                 }
1391                                                 for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
1392                                                       array[idx]->iE_Extensions->list.count;i++)
1393                                                 {
1394                                                    DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1395                                                          array[idx]->iE_Extensions->list.array[i],\
1396                                                          sizeof(ServedPLMNs_ItemExtIEs_t ));
1397                                                 }
1398                                                 DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1399                                                       array[idx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.
1400                                                       list.array[idx]->iE_Extensions->list.size);
1401                                              }
1402                                              DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1403                                                    array[idx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1404                                           }
1405                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1406                                                 array[idx]->pLMN_Identity.buf,
1407                                                 modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->pLMN_Identity.size);
1408                                        }
1409                                     }
1410                                     for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1411                                     {
1412                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
1413                                              != NULLP)
1414                                        {
1415                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
1416                                                 sizeof(ServedPLMNs_Item_t));
1417                                        }
1418                                     }
1419                                     DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1420                                           modifyItem->served_Cell_Information.servedPLMNs.list.size);
1421                                  }
1422                                  DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1423                                        modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1424                               }
1425                               DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1426                                     modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1427                            }
1428                            DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1429                                  modifyItem->oldNRCGI.nRCellIdentity.size);
1430                         }
1431                         DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
1432                               modifyItem->oldNRCGI.pLMN_Identity.size);
1433                      }
1434                   }
1435                   for(i=0; i<cellsToModify->list.count ;i++)
1436                   {
1437                      if(cellsToModify->list.array[i] != NULLP)
1438                      {
1439                         DU_FREE(cellsToModify->list.array[i],\
1440                               sizeof(Served_Cells_To_Modify_ItemIEs_t));
1441                      }
1442                   }
1443                   DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1444                }
1445             }
1446             for(i=0;i<duCfgUpdate->protocolIEs.list.count;i++)
1447             {
1448                if(duCfgUpdate->protocolIEs.list.array[i] !=NULLP)
1449                {
1450                   DU_FREE(duCfgUpdate->protocolIEs.list.array[i],\
1451                         sizeof(GNBDUConfigurationUpdateIEs_t));
1452                }
1453             }
1454             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1455          }
1456          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1457       }
1458       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1459    }
1460 }
1461
1462 /*******************************************************************
1463  *
1464  * @brief Fills Served Plmns required in ServCellInfo IE
1465  *
1466  * @details
1467  *
1468  *    Function : fillServedPlmns
1469  *
1470  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1471  *
1472  * @params[in] Pointer to ServedPLMNs_List_t *
1473  *
1474  * @return ROK     - success
1475  *         RFAILED - failure
1476  *
1477  *****************************************************************/
1478
1479 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1480 {
1481    uint8_t ieIdx, ieListCnt;
1482
1483    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
1484    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
1485          array[0]->pLMN_Identity.size);
1486    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
1487    {
1488       return RFAILED;
1489    }
1490    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
1491          servedPlmn->list.array[0]->pLMN_Identity.buf);
1492    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1493    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
1494    {
1495       return RFAILED;
1496    }
1497
1498    ieListCnt=1;
1499    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
1500    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1501    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
1502          iE_Extensions->list.size);
1503    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
1504    {
1505       return RFAILED;
1506    }
1507    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
1508    {
1509       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
1510             sizeof(ServedPLMNs_ItemExtIEs_t));
1511       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
1512       {
1513          return RFAILED;
1514       }
1515    }
1516    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
1517    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
1518    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
1519    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
1520       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1521    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1522       list.count = 1;
1523    servedPlmn->list.array[0]->\
1524       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1525       list.size = sizeof(SliceSupportItem_t *);
1526    DU_ALLOC(servedPlmn->list.array[0]->\
1527          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1528          list.array,servedPlmn->list.array[0]->\
1529          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
1530    if(servedPlmn->list.array[0]->\
1531          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1532          list.array == NULLP)
1533    {
1534       return RFAILED;
1535    }
1536
1537    DU_ALLOC(servedPlmn->list.array[0]->\
1538          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1539          list.array[0],sizeof( SliceSupportItem_t));
1540    if(servedPlmn->list.array[0]->\
1541          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1542          list.array[0] == NULLP)
1543    {
1544       return RFAILED;
1545    }
1546    servedPlmn->list.array[0]->\
1547       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1548       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
1549    DU_ALLOC(servedPlmn->list.array[0]->\
1550          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1551          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
1552          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
1553    if(servedPlmn->list.array[0]->\
1554          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1555          list.array[0]->sNSSAI.sST.buf == NULLP)
1556    {
1557       return RFAILED;
1558    }
1559    servedPlmn->list.array[0]->\
1560       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1561       list.array[0]->sNSSAI.sST.buf[0] = 3;
1562    DU_ALLOC(servedPlmn->list.array[0]->\
1563          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1564          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1565    if(servedPlmn->list.array[0]->\
1566          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1567          list.array[0]->sNSSAI.sD == NULLP)
1568    {
1569       return RFAILED;
1570    }
1571    servedPlmn->list.array[0]->\
1572       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1573       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
1574    DU_ALLOC(servedPlmn->list.array[0]->\
1575          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1576          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
1577          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1578          list.array[0]->sNSSAI.sD->size);
1579    if(servedPlmn->list.array[0]->\
1580          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1581          list.array[0]->sNSSAI.sD->buf == NULLP)
1582    {
1583       return RFAILED;
1584    }
1585    servedPlmn->list.array[0]->\
1586       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1587       list.array[0]->sNSSAI.sD->buf[0] = 3;
1588    servedPlmn->list.array[0]->\
1589       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1590       list.array[0]->sNSSAI.sD->buf[1] = 6;
1591    servedPlmn->list.array[0]->\
1592       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1593       list.array[0]->sNSSAI.sD->buf[2] = 9;
1594    return ROK;
1595 }
1596
1597 /*******************************************************************
1598  *
1599  * @brief Fills Nr Fdd Info required in ServCellInfo IE
1600  *
1601  * @details
1602  *
1603  *    Function : fillNrFddInfo
1604  *
1605  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
1606  *
1607  * @params[in] Pointer to NR_Mode_Info_t *
1608  *
1609  * @return ROK     - success
1610  *         RFAILED - failure
1611  *
1612  *****************************************************************/
1613
1614 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
1615 {
1616    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1617       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1618    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
1619    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1620    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1621          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1622    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1623    {
1624       return RFAILED;
1625    }
1626    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
1627       sizeof(FreqBandNrItem_t));
1628    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1629    {
1630       return RFAILED;
1631    }
1632    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1633       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
1634       freqBand[0].nrFreqBand;
1635    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1636    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
1637       dlNrFreqInfo.nrArfcn;
1638    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
1639    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
1640    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
1641          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1642    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1643    {
1644       return RFAILED;
1645    }
1646    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
1647          sizeof(FreqBandNrItem_t));
1648    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1649    {
1650       return RFAILED;
1651    }
1652    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1653       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
1654       freqBand[0].nrFreqBand;
1655    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1656
1657    /*Transmission Bandwidth*/
1658    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1659       f1Mode.mode.fdd.ulTxBw.nrScs;
1660    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1661       f1Mode.mode.fdd.ulTxBw.nrb;
1662    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1663       f1Mode.mode.fdd.dlTxBw.nrScs;
1664    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1665       f1Mode.mode.fdd.dlTxBw.nrb;
1666
1667    return ROK;
1668 }
1669
1670 /*******************************************************************
1671  *
1672  * @brief Fills ServCellInfo IE
1673  *
1674  * @details
1675  *
1676  *    Function : fillServedCellInfo
1677  *
1678  *    Functionality: Fills ServCellInfo
1679  *
1680  * @params[in] Pointer to Served_Cell_Information_t *
1681  *
1682  * @return ROK     - success
1683  *         RFAILED - failure
1684  *
1685  *****************************************************************/
1686
1687 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
1688 {
1689    uint8_t tmp, ieIdx, ieListCnt;
1690
1691    /*nRCGI*/
1692    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
1693    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
1694          srvCellInfo->nRCGI.pLMN_Identity.size);
1695    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
1696    {
1697       return RFAILED;
1698    }
1699    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1700          srvCellInfo->nRCGI.pLMN_Identity.buf);
1701    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
1702    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
1703          srvCellInfo->nRCGI.nRCellIdentity.size);
1704    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
1705    {
1706       return RFAILED;
1707    }
1708    for (tmp = 0 ; tmp < srvCellInfo->\
1709          nRCGI.nRCellIdentity.size-1 ; tmp++)
1710    {
1711       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
1712    }
1713    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
1714    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
1715
1716    /*nRPCI*/
1717    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1718
1719    /*servedPLMNs*/
1720    ieListCnt = 1;
1721    srvCellInfo->servedPLMNs.list.count = ieListCnt;
1722    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
1723    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
1724          srvCellInfo->servedPLMNs.list.size);
1725    if(srvCellInfo->servedPLMNs.list.array == NULLP)
1726    {
1727       return RFAILED;
1728    }
1729    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
1730    {
1731       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
1732             sizeof(ServedPLMNs_Item_t));
1733       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
1734       {
1735          return RFAILED;
1736       }
1737    }
1738    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
1739    {
1740       return RFAILED;
1741    }
1742
1743    /*nR Mode Info with FDD*/
1744    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
1745    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
1746          sizeof(FDD_Info_t));
1747    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
1748    {
1749       return RFAILED;
1750    }
1751    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
1752       return RFAILED;
1753
1754    /*Measurement timing Config*/
1755    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
1756    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
1757          buf,srvCellInfo->measurementTimingConfiguration.size);
1758    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
1759    {
1760       return RFAILED;
1761    }
1762    srvCellInfo->measurementTimingConfiguration.\
1763          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1764
1765    return ROK;
1766 }
1767
1768 /*******************************************************************
1769  *
1770  * @brief Fills ServCellToModItem IE
1771  *
1772  * @details
1773  *
1774  *    Function : fillServCellToModItem
1775  *
1776  *    Functionality: Fills ServCellToModItem IE
1777  *
1778  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
1779  *
1780  * @return ROK     - success
1781  *         RFAILED - failure
1782  *
1783  *****************************************************************/
1784
1785 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
1786 {
1787    uint8_t ieIdx;
1788
1789    /*pLMN_Identity*/
1790    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
1791    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
1792    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
1793    {
1794       return RFAILED;
1795    }
1796    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1797          modifyItem->oldNRCGI.pLMN_Identity.buf);
1798
1799    /*nRCellIdentity*/
1800    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
1801    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1802          modifyItem->oldNRCGI.nRCellIdentity.size);
1803    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
1804    {
1805       return RFAILED;
1806    }
1807    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
1808    {
1809       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
1810    }
1811    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
1812    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
1813
1814    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
1815       return RFAILED;
1816    else
1817       return ROK;
1818 }
1819
1820 /*******************************************************************
1821  *
1822  * @brief Builds ServCellToModList
1823  *
1824  * @details
1825  *
1826  *    Function : buildServCellToModList
1827  *
1828  *    Functionality: Builds the serv cell to Mod List
1829  *
1830  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
1831  *
1832  * @return ROK     - success
1833  *         RFAILED - failure
1834  *
1835  *****************************************************************/
1836
1837 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
1838 {
1839    uint8_t ieListCnt, ieIdx;
1840    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
1841
1842    ieListCnt = 1;
1843    cellsToModify->list.count = ieListCnt;
1844    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
1845    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
1846    if(cellsToModify->list.array == NULLP)
1847    {
1848       return RFAILED;
1849    }
1850    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
1851    {
1852       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
1853       if(cellsToModify->list.array[ieIdx] == NULLP)
1854       {
1855          return RFAILED;
1856       }
1857    }
1858    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
1859    cellsToModify->list.array[0]->criticality = Criticality_reject;
1860    cellsToModify->list.array[0]->value.present =\
1861       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
1862    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
1863
1864    if(fillServCellToModItem(modifyItem))
1865       return RFAILED;
1866    else
1867       return ROK;
1868 }
1869
1870 /*******************************************************************
1871  *
1872  * @brief Builds and sends the DUConfigUpdate
1873  *
1874  * @details
1875  *
1876  *    Function : BuildAndSendDUConfigUpdate
1877  *
1878  *    Functionality: Constructs the DU Update message and sends
1879  *                   it to the CU through SCTP.
1880  *
1881  * @params[in] void **buf,Buffer to which encoded pattern is written into
1882  * @params[in] int *size,size of buffer
1883  *
1884  * @return ROK     - success
1885  *         RFAILED - failure
1886  *
1887  * ****************************************************************/
1888 uint8_t BuildAndSendDUConfigUpdate()
1889 {
1890    uint8_t ret, ieIdx, elementCnt;
1891    F1AP_PDU_t                 *f1apDuCfg = NULLP;
1892    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1893    asn_enc_rval_t encRetVal;     /* Encoder return value */
1894    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
1895    ret= RFAILED;
1896
1897    while(true)
1898    {
1899       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
1900       /* Allocate the memory for F1DuCfg */
1901       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
1902       if(f1apDuCfg == NULLP)
1903       {
1904          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1905          break;
1906       }
1907
1908       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
1909       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1910       if(f1apDuCfg->choice.initiatingMessage == NULLP)
1911       {
1912          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1913          break;
1914       }
1915
1916       f1apDuCfg->choice.initiatingMessage->procedureCode = \
1917                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
1918       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
1919       f1apDuCfg->choice.initiatingMessage->value.present = \
1920                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
1921       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
1922                     choice.GNBDUConfigurationUpdate;
1923       elementCnt = 3;
1924       duCfgUpdate->protocolIEs.list.count = elementCnt;
1925       duCfgUpdate->protocolIEs.list.size = \
1926                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
1927
1928       /* Initialize the F1Setup members */
1929       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1930       if(duCfgUpdate->protocolIEs.list.array == NULLP)
1931       {
1932          DU_LOG("ERROR  -->  F1AP : Memory allocation for F1RequestIEs failed");
1933          break;
1934       }
1935       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1936       {
1937          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
1938          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
1939          {
1940             break;
1941          }
1942       }
1943
1944       /*TransactionID*/
1945       ieIdx = 0;
1946       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
1947       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
1948       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
1949          GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
1950       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
1951
1952       /*Served Cell to Modify */
1953       ieIdx++;
1954       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
1955                                                       ProtocolIE_ID_id_Served_Cells_To_Modify_List;
1956       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
1957       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
1958          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
1959       if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
1960          Served_Cells_To_Modify_List))
1961          break;
1962
1963       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
1964       /*GNB DU ID */
1965       ieIdx++;
1966       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1967       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1968       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
1969         GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
1970       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
1971       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1972             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1973       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
1974       {
1975          break;
1976       }
1977       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
1978
1979       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
1980
1981       /* Encode the DU Config Update type as APER */
1982       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
1983       encBufSize = 0;
1984       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
1985
1986       /* Checking encode results */
1987       if(encRetVal.encoded == ENCODE_FAIL)
1988       {
1989          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
1990          encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1991          break;
1992       }
1993       else
1994       {
1995          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
1996          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
1997          {
1998             printf("%x",encBuf[ieIdx]);
1999          }
2000       }
2001       /* Sending msg */
2002       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
2003       {
2004          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2005          break;
2006       }
2007
2008       ret = ROK;
2009       break;
2010    }
2011    FreeDUConfigUpdate(f1apDuCfg);
2012
2013    return ret;
2014 }
2015
2016
2017 /*******************************************************************
2018  *
2019  * @brief free the ULRRCMessageTransfer
2020  *
2021  * @details
2022  *
2023  *    Function : FreeULRRCMessageTransfer
2024  *
2025  *    Functionality: Deallocating the memory of variable allocated in
2026  *                      FreeULRRCMessageTransfer
2027  *
2028  * @params[in]
2029  *
2030  * @return ROK     - void
2031  *
2032  ******************************************************************/
2033 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2034 {
2035    uint8_t idx1;
2036    ULRRCMessageTransfer_t  *ulRRCMsg;
2037
2038    if(f1apMsg != NULLP)
2039    {
2040       if(f1apMsg->choice.initiatingMessage != NULLP)
2041       {
2042          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2043          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2044          {
2045             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2046             {
2047                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2048                {
2049                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2050                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2051                   {
2052                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2053                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2054                   }
2055                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2056                }
2057             }
2058             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2059          }
2060          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2061       }
2062       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2063    }
2064 }
2065 /*******************************************************************
2066  *
2067  * @brief Builds and sends the ULRRCMessageTransfer
2068  *
2069  * @details
2070  *
2071  *    Function : BuildAndSendULRRCMessageTransfer
2072  *
2073  *    Functionality: Constructs the UL RRC Message Transfer and sends
2074  *                   it to the CU through SCTP.
2075  *
2076  * @params[in]
2077  *
2078  * @return ROK     - success
2079  *         RFAILED - failure
2080  *
2081  * ****************************************************************/
2082 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2083       uint16_t msgLen, uint8_t *rrcMsg)
2084 {
2085    uint8_t   elementCnt =0;
2086    uint8_t   idx1 =0;
2087    uint8_t   idx =0;
2088    F1AP_PDU_t                   *f1apMsg = NULLP;
2089    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2090    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2091    uint8_t ret =RFAILED;
2092
2093    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2094
2095    while(true)
2096    {
2097       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2098
2099       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2100       if(f1apMsg == NULLP)
2101       {
2102          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2103          break;
2104       }
2105       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2106       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2107       if(f1apMsg->choice.initiatingMessage == NULLP)
2108       {
2109          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2110          break;
2111       }
2112       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2113       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2114       f1apMsg->choice.initiatingMessage->value.present = \
2115                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2116       ulRRCMsg =
2117          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2118       elementCnt = 4;
2119       ulRRCMsg->protocolIEs.list.count = elementCnt;
2120       ulRRCMsg->protocolIEs.list.size = \
2121                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2122
2123       /* Initialize the F1Setup members */
2124       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2125       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2126       {
2127          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2128          break;
2129       }
2130       for(idx=0; idx<elementCnt; idx++)
2131       {
2132          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2133          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2134          {
2135             break;
2136          }
2137       }
2138
2139       idx1 = 0;
2140
2141       /*GNB CU UE F1AP ID*/
2142       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2143       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2144       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2145                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2146       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2147
2148       /*GNB DU UE F1AP ID*/
2149       idx1++;
2150       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2151       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2152       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2153                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2154       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2155
2156       /*SRBID*/
2157       idx1++;
2158       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2159       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2160       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2161                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2162       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2163
2164       /*RRCContainer*/
2165       idx1++;
2166       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2167       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2168       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2169                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2170       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2171       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2172             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2173       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2174       {
2175          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2176          break;
2177       }
2178       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2179       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2180             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2181
2182       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2183
2184       /* Encode the F1SetupRequest type as APER */
2185       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2186       encBufSize = 0;
2187       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2188             encBuf);
2189       /* Encode results */
2190       if(encRetVal.encoded == ENCODE_FAIL)
2191       {
2192          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2193                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2194          break;
2195       }
2196       else
2197       {
2198          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2199          for(int i=0; i< encBufSize; i++)
2200          {
2201             printf("%x",encBuf[i]);
2202          }
2203       }
2204
2205       /* Sending  msg  */
2206       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) !=      ROK)
2207       {
2208          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2209          break;
2210       }
2211       ret = ROK;
2212       break;
2213    }
2214    FreeULRRCMessageTransfer(f1apMsg);
2215
2216    return ret;
2217 }/* End of BuildAndSendULRRCMessageTransfer*/
2218
2219 /*******************************************************************
2220  *
2221  * @brief Builds tag config
2222  *
2223  * @details
2224  *
2225  *    Function : BuildTagConfig
2226  *
2227  *    Functionality: Builds tag config in MacCellGroupConfig
2228  *
2229  * @params[in] TAG_Config *tag_Config
2230  *
2231  * @return ROK     - success
2232  *         RFAILED - failure
2233  *
2234  * ****************************************************************/
2235 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2236 {
2237    struct TAG_Config__tag_ToAddModList *tagList;
2238    uint8_t                     idx, elementCnt;
2239
2240    tagConfig->tag_ToReleaseList = NULLP;
2241    tagConfig->tag_ToAddModList = NULLP;
2242    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2243    if(!tagConfig->tag_ToAddModList)
2244    {
2245       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2246       return RFAILED;
2247    }
2248
2249    elementCnt = 1; //ODU_VALUE_ONE;
2250    tagList = tagConfig->tag_ToAddModList;
2251    tagList->list.count = elementCnt;
2252    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2253
2254    tagList->list.array = NULLP;
2255    DU_ALLOC(tagList->list.array, tagList->list.size);
2256    if(!tagList->list.array)
2257    {
2258       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2259       return RFAILED;
2260    }
2261
2262    for(idx=0; idx<tagList->list.count; idx++)
2263    {
2264       tagList->list.array[idx] = NULLP;
2265       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2266       if(!tagList->list.array[idx])
2267       {
2268          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2269          return RFAILED;
2270       }
2271    }
2272
2273    idx = 0;
2274    tagList->list.array[idx]->tag_Id = TAG_ID;
2275    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2276
2277    return ROK;
2278 }
2279
2280 /*******************************************************************
2281  *
2282  * @brief Builds PHR Config
2283  *
2284  * @details
2285  *
2286  *    Function : BuildPhrConfig
2287  *
2288  *    Functionality: Builds phrConfig in MacCellGroupConfig
2289  *
2290  * @params[in] PHR Config *
2291  *
2292  * @return ROK     - success
2293  *         RFAILED - failure
2294  *
2295  * ****************************************************************/
2296 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2297 {
2298
2299    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2300    phrConfig->choice.setup = NULLP;
2301    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2302    if(!phrConfig->choice.setup)
2303    {
2304       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2305       return RFAILED;
2306    }
2307
2308    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2309    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2310    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2311    phrConfig->choice.setup->multiplePHR              = false;
2312    phrConfig->choice.setup->dummy                    = false;
2313    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2314    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2315
2316    return ROK;
2317 }
2318
2319 /*******************************************************************
2320  *
2321  * @brief Builds BSR Config
2322  *
2323  * @details
2324  *
2325  *    Function : BuildBsrConfig
2326  *
2327  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2328  *
2329  * @params[in] BSR_Config *bsrConfig
2330  *
2331  * @return ROK     - success
2332  *         RFAILED - failure
2333  *
2334  * ****************************************************************/
2335 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2336 {
2337    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2338    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2339    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2340
2341    return ROK;
2342 }
2343
2344 /*******************************************************************
2345  *
2346  * @brief Builds scheduling request config
2347  *
2348  * @details
2349  *
2350  *    Function : BuildSchedulingReqConfig
2351  *
2352  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2353  *
2354  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2355  *
2356  * @return ROK     - success
2357  *         RFAILED - failure
2358  *
2359  * ****************************************************************/
2360 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
2361 {
2362    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2363    uint8_t                     idx, elementCnt;
2364
2365    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2366    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2367          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2368    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2369    {
2370       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2371       return RFAILED;
2372    }
2373
2374    elementCnt = 1; //ODU_VALUE_ONE;
2375    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2376    schReqList->list.count = elementCnt;
2377    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2378
2379    schReqList->list.array = NULLP;
2380    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2381    if(!schReqList->list.array)
2382    {
2383       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2384       return RFAILED;
2385    }
2386
2387    for(idx=0;idx<schReqList->list.count; idx++)
2388    {
2389       schReqList->list.array[idx] = NULLP;
2390       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2391       if(!schReqList->list.array[idx])
2392       {
2393          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2394          return RFAILED;
2395       }
2396    }
2397
2398    idx = 0;
2399    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2400
2401    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2402    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2403    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2404    {
2405       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2406       return RFAILED;
2407    }
2408    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2409    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2410    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2411
2412    return ROK;
2413 }
2414
2415 /*******************************************************************
2416  *
2417  * @brief Builds RLC Config
2418  *
2419  * @details
2420  *
2421  *    Function : BuildRlcConfig
2422  *
2423  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
2424  *
2425  * @params[in] RLC_Config *rlcConfig
2426  *
2427  * @return ROK     - success
2428  *         RFAILED - failure
2429  *
2430  * ****************************************************************/
2431 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
2432 {
2433
2434    rlcConfig->present = RLC_Config_PR_am;
2435
2436    rlcConfig->choice.am = NULLP;
2437    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2438    if(!rlcConfig->choice.am)
2439    {
2440       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2441       return RFAILED;
2442    }
2443
2444    /* UL */
2445    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2446    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2447    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2448    {
2449       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2450       return RFAILED;
2451    }
2452    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2453    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2454    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2455    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2456    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2457
2458    /* DL */
2459    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2460    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2461    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2462    {
2463       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2464       return RFAILED;
2465    }
2466    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2467    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
2468    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
2469
2470    return ROK;
2471 }
2472
2473 /*******************************************************************
2474  *
2475  * @brief Builds MAC LC Config
2476  *
2477  * @details
2478  *
2479  *    Function : BuildMacLCConfig
2480  *
2481  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
2482  *
2483  * @params[in] struct LogicalChannelConfig macLcConfig
2484  *
2485  * @return ROK     - success
2486  *         RFAILED - failure
2487  *
2488  * ****************************************************************/
2489 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
2490 {
2491
2492    macLcConfig->ul_SpecificParameters = NULLP;
2493    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
2494    if(!macLcConfig->ul_SpecificParameters)
2495    {
2496       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
2497       return RFAILED;
2498    }
2499
2500    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
2501    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
2502    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
2503    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
2504    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
2505    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
2506    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
2507
2508    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
2509    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
2510    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
2511    {
2512       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
2513       return RFAILED;
2514    }
2515    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
2516
2517    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
2518    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
2519    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
2520    {
2521       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
2522       return RFAILED;
2523    }
2524    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
2525
2526    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
2527    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
2528    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
2529
2530    return ROK;
2531 }
2532
2533 /*******************************************************************
2534  *
2535  * @brief Builds RLC Bearer to Add/Mod list
2536  *
2537  * @details
2538  *
2539  *    Function :BuildRlcBearerToAddModList
2540  *
2541  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
2542  *
2543  * @params[in] rlc_BearerToAddModList
2544  *
2545  * @return ROK     - success
2546  *         RFAILED - failure
2547  *
2548  * ****************************************************************/
2549 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
2550 {
2551    uint8_t                     idx, elementCnt;
2552
2553    elementCnt = 1;
2554    rlcBearerList->list.count = elementCnt;
2555    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
2556
2557    rlcBearerList->list.array = NULLP;
2558    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
2559    if(!rlcBearerList->list.array)
2560    {
2561       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2562       return RFAILED;
2563    }
2564
2565    for(idx=0; idx<rlcBearerList->list.count; idx++)
2566    {
2567       rlcBearerList->list.array[idx] = NULLP;
2568       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
2569       if(!rlcBearerList->list.array[idx])
2570       {
2571          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2572          return RFAILED;
2573       }
2574    }
2575
2576    idx = 0;
2577    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
2578
2579    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
2580       sizeof(struct RLC_BearerConfig__servedRadioBearer));
2581    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
2582    {
2583       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2584       return RFAILED;
2585    }
2586
2587    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
2588       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
2589    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
2590       SRB1_LCID;
2591
2592    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
2593    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
2594    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
2595    if(!rlcBearerList->list.array[idx]->rlc_Config)
2596    {
2597       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2598       return RFAILED;
2599    }
2600
2601    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
2602    {
2603       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
2604       return RFAILED;
2605    }
2606
2607    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
2608    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
2609       sizeof(struct LogicalChannelConfig));
2610    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
2611    {
2612       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2613       return RFAILED;
2614    }
2615
2616    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
2617    {
2618       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
2619       return RFAILED;
2620    }
2621
2622    return ROK;
2623 }
2624
2625 /*******************************************************************
2626  *
2627  * @brief Build Control resource set to add/modify list
2628  *
2629  * @details
2630  *
2631  *    Function : BuildControlRSetToAddModList
2632  *
2633  *    Functionality: Build Control resource set to add/modify list
2634  *
2635  * @params[in]
2636  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2637  *
2638  * @return ROK     - success
2639  *         RFAILED - failure
2640  *
2641  * ****************************************************************/
2642    uint8_t BuildControlRSetToAddModList
2643 (
2644  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2645  )
2646 {
2647    uint8_t idx;
2648    uint8_t elementCnt;
2649    uint8_t numBytes, bitsUnused;
2650    struct ControlResourceSet *controlRSet;
2651    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
2652    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
2653
2654
2655    elementCnt = 1;
2656    controlRSetList->list.count = elementCnt;
2657    controlRSetList->list.size = \
2658                                 elementCnt * sizeof(struct ControlResourceSet *);
2659
2660    controlRSetList->list.array = NULLP;
2661    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
2662    if(!controlRSetList->list.array)
2663    {
2664       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2665       return RFAILED;
2666    }
2667
2668    for(idx = 0; idx < elementCnt; idx++)
2669    {
2670       controlRSetList->list.array[idx] = NULLP;
2671       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
2672       if(!controlRSetList->list.array[idx])
2673       {
2674          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2675          return RFAILED;
2676       }
2677    }
2678
2679    idx=0;
2680    controlRSet = controlRSetList->list.array[idx];
2681
2682    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
2683
2684    /* size 6 bytes
2685     * 3 LSBs unsued
2686     * Bit string stored ff0000000000
2687     */
2688    numBytes = 6;
2689    bitsUnused = 3;
2690    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
2691
2692    controlRSet->frequencyDomainResources.buf = NULLP;
2693    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
2694          controlRSet->frequencyDomainResources.size);
2695    if(!controlRSet->frequencyDomainResources.buf)
2696    {
2697       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2698       return RFAILED;
2699    }
2700
2701    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
2702    coreset0EndPrb = CORESET0_END_PRB;
2703    coreset1StartPrb = coreset0EndPrb + 6;
2704    coreset1NumPrb = CORESET1_NUM_PRB;
2705    /* calculate the PRBs */
2706    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
2707    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
2708    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
2709
2710    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
2711    controlRSet->cce_REG_MappingType.present = \
2712                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
2713
2714    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
2715    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
2716    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
2717    controlRSet->tci_PresentInDCI = NULLP;
2718 #if 0
2719    uint8_t tciStateIdx;
2720
2721    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
2722          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
2723    if(!controlRset->tci_StatesPDCCH_ToAddList)
2724    {
2725       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2726       return RFAILED;
2727    }
2728
2729    elementCnt = 1;
2730    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
2731    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
2732    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
2733          controlRset->tci_StatesPDCCH_ToAddList->list.size)
2734       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
2735       {
2736          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2737          return RFAILED;
2738       }
2739
2740    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
2741    {
2742       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
2743       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
2744       {
2745          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2746          return RFAILED;
2747       }
2748    }
2749
2750    tciStateIdx = 0;
2751    /* TODO */
2752    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
2753
2754    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
2755    if(!controlRset->tci_PresentInDCI)
2756    {
2757       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2758       return RFAILED;
2759    }
2760    /* TODO */
2761    *(controlRset->tci_PresentInDCI);
2762 #endif
2763
2764    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
2765    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
2766    if(!controlRSet->pdcch_DMRS_ScramblingID)
2767    {
2768       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2769       return RFAILED;
2770    }
2771    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
2772
2773    return ROK;
2774 } /* End BuildControlRSetToAddModList */
2775
2776 /*******************************************************************
2777  *
2778  * @brief Build search space to add/modify list
2779  *
2780  * @details
2781  *
2782  *    Function : BuildSearchSpcToAddModList
2783  *
2784  *    Functionality: Build search space to add/modify list
2785  *
2786  * @params[in]
2787  * @return ROK     - success
2788  *         RFAILED - failure
2789  *
2790  * ****************************************************************/
2791    uint8_t BuildSearchSpcToAddModList
2792 (
2793  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
2794  )
2795 {
2796    uint8_t idx;
2797    uint8_t numBytes;
2798    uint8_t byteIdx;
2799    uint8_t bitsUnused;
2800    uint8_t elementCnt;
2801    struct SearchSpace *searchSpc;
2802
2803    elementCnt = 1;
2804    searchSpcList->list.count = elementCnt;
2805    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
2806
2807    searchSpcList->list.array = NULLP;
2808    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
2809    if(!searchSpcList->list.array)
2810    {
2811       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2812       return RFAILED;
2813    }
2814
2815    for(idx = 0; idx < elementCnt; idx++)
2816    {
2817       searchSpcList->list.array[idx] = NULLP;
2818       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
2819       if(!searchSpcList->list.array[idx])
2820       {
2821          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2822          return RFAILED;
2823       }
2824    }
2825
2826    idx = 0;
2827    searchSpc = searchSpcList->list.array[idx];
2828
2829    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
2830
2831    searchSpc->controlResourceSetId = NULLP;
2832    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
2833    if(!searchSpc->controlResourceSetId)
2834    {
2835       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2836       return RFAILED;
2837    }
2838    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
2839
2840    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
2841    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
2842          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
2843    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
2844    {
2845       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2846       return RFAILED;
2847    }
2848    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
2849                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
2850
2851    searchSpc->duration = NULLP;
2852    searchSpc->monitoringSymbolsWithinSlot = NULLP;
2853    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
2854    if(!searchSpc->monitoringSymbolsWithinSlot)
2855    {
2856       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2857       return RFAILED;
2858    }
2859
2860    /* Values taken from reference logs :
2861     * size 2 bytes
2862     * 2 LSBs unsued
2863     * Bit string stores 8000
2864     */
2865    numBytes = 2;
2866    bitsUnused = 2;
2867
2868    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
2869    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
2870    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
2871          searchSpc->monitoringSymbolsWithinSlot->size);
2872    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
2873    {
2874       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2875       return RFAILED;
2876    }
2877
2878    byteIdx = 0;
2879    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
2880                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
2881    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
2882    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
2883
2884    searchSpc->nrofCandidates = NULLP;
2885    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
2886    if(!searchSpc->nrofCandidates)
2887    {
2888       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2889       return RFAILED;
2890    }
2891
2892    searchSpc->nrofCandidates->aggregationLevel1 = \
2893                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
2894    searchSpc->nrofCandidates->aggregationLevel2 = \
2895                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
2896    searchSpc->nrofCandidates->aggregationLevel4 = \
2897                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
2898    searchSpc->nrofCandidates->aggregationLevel8 = \
2899                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
2900    searchSpc->nrofCandidates->aggregationLevel16 = \
2901                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
2902
2903    searchSpc->searchSpaceType = NULLP;
2904    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
2905    if(!searchSpc->searchSpaceType)
2906    {
2907       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2908       return RFAILED;
2909    }
2910
2911    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
2912
2913    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
2914    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
2915          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
2916    if(!searchSpc->searchSpaceType->choice.ue_Specific)
2917    {
2918       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2919       return RFAILED;
2920    }
2921    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
2922                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
2923
2924    return ROK;
2925 }/* End BuildSearchSpcToAddModList */
2926
2927 /*******************************************************************
2928  *
2929  * @brief Builds BWP DL dedicated PDCCH config
2930  *
2931  * @details
2932  *
2933  *    Function : BuildBWPDlDedPdcchCfg
2934  *
2935  *    Functionality: Builds BWP DL dedicated PDCCH config
2936  *
2937  * @params[in] struct PDCCH_Config *pdcchCfg
2938  *
2939  * @return ROK     - success
2940  *         RFAILED - failure
2941  *
2942  * ****************************************************************/
2943 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
2944 {
2945    pdcchCfg->controlResourceSetToAddModList = NULLP;
2946    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
2947          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
2948    if(!pdcchCfg->controlResourceSetToAddModList)
2949    {
2950       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
2951       return RFAILED;
2952    }
2953
2954    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
2955    {
2956       return RFAILED;
2957    }
2958
2959    pdcchCfg->controlResourceSetToReleaseList = NULLP;
2960
2961    pdcchCfg->searchSpacesToAddModList = NULLP;
2962    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
2963          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
2964    if(!pdcchCfg->searchSpacesToAddModList)
2965    {
2966       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
2967       return RFAILED;
2968    }
2969
2970    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
2971    {
2972       return RFAILED;
2973    }
2974
2975    pdcchCfg->searchSpacesToReleaseList = NULLP;
2976    pdcchCfg->downlinkPreemption = NULLP;
2977    pdcchCfg->tpc_PUSCH = NULLP;
2978    pdcchCfg->tpc_PUCCH = NULLP;
2979    pdcchCfg->tpc_SRS = NULLP;
2980
2981    return ROK;
2982 }
2983
2984 /*******************************************************************
2985  *
2986  * @brief Builds DMRS DL PDSCH Mapping type A
2987  *
2988  * @details
2989  *
2990  *    Function : BuildDMRSDLPdschMapTypeA
2991  *
2992  *    Functionality: Builds DMRS DL PDSCH Mapping type A
2993  *
2994  * @params[in]
2995  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
2996  * @return ROK     - success
2997  *         RFAILED - failure
2998  *
2999  * ****************************************************************/
3000    uint8_t BuildDMRSDLPdschMapTypeA
3001 (
3002  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3003  )
3004 {
3005    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3006    dmrsDlCfg->choice.setup = NULLP;
3007    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3008    if(!dmrsDlCfg->choice.setup)
3009    {
3010       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3011       return RFAILED;
3012    }
3013
3014    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3015    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3016    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3017    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3018    {
3019       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3020       return RFAILED;
3021    }
3022    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3023
3024    dmrsDlCfg->choice.setup->maxLength = NULLP;
3025    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3026    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3027    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3028
3029    return ROK;
3030 }
3031
3032 /*******************************************************************
3033  *
3034  * @brief Builds TCI states to add/modify list
3035  *
3036  * @details
3037  *
3038  *    Function : BuildTCIStatesToAddModList
3039  *
3040  *    Functionality:Builds TCI states to add/modify list
3041  *
3042  * @params[in]
3043  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3044  *
3045  * @return ROK     - success
3046  *         RFAILED - failure
3047  *
3048  * ****************************************************************/
3049 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3050 {
3051    return ROK;
3052 }
3053
3054 /*******************************************************************
3055  *
3056  * @brief Builds PDSCH time domain allocation list
3057  *
3058  * @details
3059  *
3060  *    Function : BuildPdschTimeDomAllocList
3061  *
3062  *    Functionality: Builds PDSCH time domain allocation list
3063  *
3064  * @params[in]
3065  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3066  *
3067  * @return ROK     - success
3068  *         RFAILED - failure
3069  *
3070  * ****************************************************************/
3071    uint8_t BuildPdschTimeDomAllocList
3072 (
3073  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3074  )
3075 {
3076    uint8_t idx;
3077    uint8_t elementCnt;
3078    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3079
3080    timeDomAllocList->present = \
3081                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3082
3083    timeDomAllocList->choice.setup = NULLP;
3084    DU_ALLOC(timeDomAllocList->choice.setup, \
3085          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3086    if(!timeDomAllocList->choice.setup)
3087    {
3088       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3089       return RFAILED;
3090    }
3091
3092    elementCnt = 1;
3093    timeDomAllocList->choice.setup->list.count = elementCnt;
3094    timeDomAllocList->choice.setup->list.size = \
3095                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3096
3097    timeDomAllocList->choice.setup->list.array = NULLP;
3098    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3099          timeDomAllocList->choice.setup->list.size);
3100    if(!timeDomAllocList->choice.setup->list.array)
3101    {
3102       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3103       return RFAILED;
3104    }
3105
3106    for(idx = 0; idx < elementCnt; idx++)
3107    {
3108       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3109       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3110             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3111       if(!timeDomAllocList->choice.setup->list.array[idx])
3112       {
3113          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3114          return RFAILED;
3115       }
3116    }
3117
3118    idx = 0;
3119    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3120
3121    timeDomAlloc->k0 = NULLP;
3122    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3123    timeDomAlloc->startSymbolAndLength = \
3124                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3125
3126    return ROK;
3127 }
3128
3129 /*******************************************************************
3130  *
3131  * @brief Builds PDSCH PRB Bundling type
3132  *
3133  * @details
3134  *
3135  *    Function : BuildPdschPrbBundlingType
3136  *
3137  *    Functionality: Builds PDSCH PRB Bundling type
3138  *
3139  * @params[in]
3140  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3141  *
3142  * @return ROK     - success
3143  *         RFAILED - failure
3144  *
3145  * ****************************************************************/
3146    uint8_t BuildPdschPrbBundlingType
3147 (
3148  struct PDSCH_Config__prb_BundlingType *prbBndlType
3149  )
3150 {
3151    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3152
3153    prbBndlType->choice.staticBundling = NULLP;
3154    DU_ALLOC(prbBndlType->choice.staticBundling, \
3155          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3156    if(!prbBndlType->choice.staticBundling)
3157    {
3158       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3159       return RFAILED;
3160    }
3161    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3162
3163    return ROK;
3164 }
3165
3166 /*******************************************************************
3167  *
3168  * @brief Builds BWP DL dedicated PDSCH config
3169  *
3170  * @details
3171  *
3172  *    Function : BuildBWPDlDedPdschCfg
3173  *
3174  *    Functionality: Builds BWP DL dedicated PDSCH config
3175  *
3176  * @params[in] struct PDSCH_Config *pdschCfg
3177  *
3178  * @return ROK     - success
3179  *         RFAILED - failure
3180  *
3181  * ****************************************************************/
3182 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3183 {
3184    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3185
3186    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3187    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3188          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3189    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3190    {
3191       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3192       return RFAILED;
3193    }
3194
3195    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3196    {
3197       return RFAILED;
3198    }
3199
3200    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3201    pdschCfg->tci_StatesToAddModList = NULLP;
3202    pdschCfg->tci_StatesToReleaseList = NULLP;
3203    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3204 #if 0
3205    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3206    if(!pdschCfg->tci_StatesToAddModList)
3207    {
3208       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3209       return RFAILED;
3210    }
3211    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3212    {
3213       return RFAILED;
3214    }
3215 #endif
3216
3217    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3218
3219    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3220    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3221          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3222    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3223    {
3224       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3225       return RFAILED;
3226    }
3227
3228    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3229    {
3230       return RFAILED;
3231    }
3232
3233    pdschCfg->pdsch_AggregationFactor = NULLP;
3234    pdschCfg->rateMatchPatternToAddModList = NULLP;
3235    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3236    pdschCfg->rateMatchPatternGroup1 = NULLP;
3237    pdschCfg->rateMatchPatternGroup2 = NULLP;
3238    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3239    pdschCfg->mcs_Table = NULLP;
3240
3241    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3242    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3243    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3244    {
3245       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3246       return RFAILED;
3247    }
3248    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3249
3250    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3251    {
3252       return RFAILED;
3253    }
3254
3255    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3256    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3257    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3258    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3259    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3260    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3261    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3262
3263    return ROK;
3264 }
3265
3266 /*******************************************************************
3267  *
3268  * @brief Builds intitial DL BWP
3269  * @details
3270  *
3271  *    Function : BuildInitialDlBWP
3272  *
3273  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3274  *
3275  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3276  *
3277  * @return ROK     - success
3278  *         RFAILED - failure
3279  *
3280  * ****************************************************************/
3281 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3282 {
3283    dlBwp->pdcch_Config = NULLP;
3284    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3285    if(!dlBwp->pdcch_Config)
3286    {
3287       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3288       return RFAILED;
3289    }
3290    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3291
3292    dlBwp->pdcch_Config->choice.setup = NULLP;
3293    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3294    if(!dlBwp->pdcch_Config->choice.setup)
3295    {
3296       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3297       return RFAILED;
3298    }
3299    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3300    {
3301       return RFAILED;
3302    }
3303
3304    dlBwp->pdsch_Config = NULLP;
3305    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3306    if(!dlBwp->pdsch_Config)
3307    {
3308       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3309       return RFAILED;
3310    }
3311    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3312
3313    dlBwp->pdsch_Config->choice.setup = NULLP;
3314    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3315    if(!dlBwp->pdsch_Config->choice.setup)
3316    {
3317       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3318       return RFAILED;
3319    }
3320
3321    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3322    {
3323       return RFAILED;
3324    }
3325
3326    dlBwp->sps_Config = NULLP;
3327    dlBwp->radioLinkMonitoringConfig = NULLP;
3328    return ROK;
3329 }
3330
3331 /*******************************************************************
3332  *
3333  * @brief Builds DMRS UL Pusch Mapping type A
3334  *
3335  * @details
3336  *
3337  *    Function : BuildDMRSULPuschMapTypeA
3338  *
3339  *    Functionality: Builds DMRS UL Pusch Mapping type A
3340  *
3341  * @params[in]
3342  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3343  * @return ROK     - success
3344  *         RFAILED - failure
3345  *
3346  * ****************************************************************/
3347    uint8_t BuildDMRSULPuschMapTypeA
3348 (
3349  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3350  )
3351 {
3352    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3353    dmrsUlCfg->choice.setup= NULLP;
3354    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3355    if(!dmrsUlCfg->choice.setup)
3356    {
3357       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3358       return RFAILED;
3359    }
3360
3361    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3362    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3363    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3364    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3365    {
3366       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3367       return RFAILED;
3368    }
3369    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3370
3371    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3372    dmrsUlCfg->choice.setup->maxLength = NULLP;
3373    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3374    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3375          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3376    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3377    {
3378       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3379       return RFAILED;
3380    }
3381
3382    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3383    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3384          sizeof(long));
3385    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3386    {
3387       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3388       return RFAILED;
3389    }
3390    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3391
3392    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3393    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3394    return ROK;
3395 }
3396
3397 /*******************************************************************
3398  *
3399  * @brief Build PUSCH time domain allocation list
3400  *
3401  * @details
3402  *
3403  *    Function : BuildPuschTimeDomAllocList
3404  *
3405  *    Functionality: Build PUSCH time domain allocation list
3406  *
3407  * @params[in]
3408  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3409  *
3410  * @return ROK     - success
3411  *         RFAILED - failure
3412  *
3413  * ****************************************************************/
3414    uint8_t BuildPuschTimeDomAllocList
3415 (
3416  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3417  )
3418 {
3419    uint8_t idx;
3420    uint8_t elementCnt;
3421    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3422
3423    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3424    timeDomAllocList->choice.setup = NULLP;
3425    DU_ALLOC(timeDomAllocList->choice.setup, \
3426          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3427    if(!timeDomAllocList->choice.setup)
3428    {
3429       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3430       return RFAILED;
3431    }
3432
3433    elementCnt = 1;
3434    timeDomAllocList->choice.setup->list.count = elementCnt;
3435    timeDomAllocList->choice.setup->list.size = \
3436                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3437    timeDomAllocList->choice.setup->list.array = NULLP;
3438    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3439          timeDomAllocList->choice.setup->list.size);
3440    if(!timeDomAllocList->choice.setup->list.array)
3441    {
3442       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3443       return RFAILED;
3444    }
3445
3446    for(idx = 0; idx < elementCnt; idx++)
3447    {
3448       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3449       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3450             sizeof(PUSCH_TimeDomainResourceAllocation_t));
3451       if(!timeDomAllocList->choice.setup->list.array[idx])
3452       {
3453          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3454          return RFAILED;
3455       }
3456    }
3457
3458    idx = 0;
3459    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3460    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
3461    if(!timeDomAlloc->k2)
3462    {
3463       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3464       return RFAILED;
3465    }
3466    *(timeDomAlloc->k2) = PUSCH_K2;
3467    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3468    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
3469    return ROK;
3470 }
3471
3472 /*******************************************************************
3473  *
3474  * @brief Builds BWP UL dedicated PUSCH Config
3475  *
3476  * @details
3477  *
3478  *    Function : BuildBWPUlDedPuschCfg
3479  *
3480  *    Functionality:
3481  *      Builds BWP UL dedicated PUSCH Config
3482  *
3483  * @params[in] : PUSCH_Config_t *puschCfg
3484  *
3485  * @return ROK     - success
3486  *         RFAILED - failure
3487  *
3488  * ****************************************************************/
3489 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3490 {
3491    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3492    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3493    if(!puschCfg->dataScramblingIdentityPUSCH)
3494    {
3495       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3496       return RFAILED;
3497    }
3498    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3499
3500    puschCfg->txConfig = NULLP;
3501    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3502    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3503          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3504    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3505    {
3506       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3507       return RFAILED;
3508    }
3509
3510    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
3511    {
3512       return RFAILED;
3513    }
3514
3515    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
3516    puschCfg->pusch_PowerControl = NULLP;
3517    puschCfg->frequencyHopping = NULLP;
3518    puschCfg->frequencyHoppingOffsetLists = NULLP;
3519    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
3520
3521    puschCfg->pusch_TimeDomainAllocationList = NULLP;
3522    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
3523          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
3524    if(!puschCfg->pusch_TimeDomainAllocationList)
3525    {
3526       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3527       return RFAILED;
3528    }
3529
3530    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
3531    {
3532       return RFAILED;
3533    }
3534
3535    puschCfg->pusch_AggregationFactor = NULLP;
3536    puschCfg->mcs_Table = NULLP;
3537    puschCfg->mcs_TableTransformPrecoder = NULLP;
3538    puschCfg->transformPrecoder = NULLP;
3539    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
3540    if(!puschCfg->transformPrecoder)
3541    {
3542       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3543       return RFAILED;
3544    }
3545    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
3546
3547    puschCfg->codebookSubset = NULLP;
3548    puschCfg->maxRank = NULLP;
3549    puschCfg->rbg_Size = NULLP;
3550    puschCfg->uci_OnPUSCH = NULLP;
3551    puschCfg->tp_pi2BPSK = NULLP;
3552
3553    return ROK;
3554 }
3555
3556 /*******************************************************************
3557  *
3558  * @brief Fills SRS resource to add/modify list
3559  *
3560  * @details
3561  *
3562  *    Function : BuildSrsRsrcAddModList
3563  *
3564  *    Functionality: Fills SRS resource to add/modify list
3565  *
3566  * @params[in]
3567  * @return ROK     - success
3568  *         RFAILED - failure
3569  *
3570  * ****************************************************************/
3571 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
3572 {
3573    uint8_t   elementCnt;
3574    uint8_t   rsrcIdx;
3575
3576    elementCnt = 1;
3577    resourceList->list.count = elementCnt;
3578    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
3579    resourceList->list.array = NULLP;
3580    DU_ALLOC(resourceList->list.array, resourceList->list.size);
3581    if(!resourceList->list.array)
3582    {
3583       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
3584       return RFAILED;
3585    }
3586
3587    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
3588    {
3589       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
3590       if(!resourceList->list.array[rsrcIdx])
3591       {
3592          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
3593          return RFAILED;
3594       }
3595    }
3596
3597    rsrcIdx = 0;
3598    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
3599    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
3600    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
3601
3602    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
3603    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
3604          sizeof(struct SRS_Resource__transmissionComb__n2));
3605    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
3606    {
3607       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
3608       return RFAILED;
3609    }
3610    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
3611       = SRS_COMB_OFFSET_N2;
3612    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
3613       = SRS_CYCLIC_SHIFT_N2;
3614
3615    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
3616                                                                       PUSCH_START_SYMBOL;
3617    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
3618                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
3619    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
3620                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
3621
3622    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
3623    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
3624    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
3625    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
3626    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
3627    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
3628                                                                SRS_Resource__groupOrSequenceHopping_neither;
3629
3630    /* Setting resource type to aperiodic for intergration purposes */
3631    resourceList->list.array[rsrcIdx]->resourceType.present = \
3632                                                              SRS_Resource__resourceType_PR_aperiodic;
3633    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
3634    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
3635          sizeof(struct SRS_Resource__resourceType__aperiodic));
3636    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
3637    {
3638       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
3639       return RFAILED;
3640    }
3641    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
3642
3643    return ROK;
3644 }
3645
3646 /*******************************************************************
3647  *
3648  * @brief Build SRS resource set Add/mod list
3649  *
3650  * @details
3651  *
3652  *    Function : BuildSrsRsrcSetAddModList
3653  *
3654  *    Functionality: Build SRS resource set Add/mod list
3655  *
3656  * @params[in]
3657  * @return ROK     - success
3658  *         RFAILED - failure
3659  *
3660  * ****************************************************************/
3661    uint8_t BuildSrsRsrcSetAddModList
3662 (
3663  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
3664  )
3665 {
3666    uint8_t  elementCnt;
3667    uint8_t  rSetIdx;
3668    uint8_t  rsrcIdx;
3669    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
3670
3671    elementCnt = 1;
3672    rsrcSetList->list.count = elementCnt;
3673    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
3674    rsrcSetList->list.array = NULLP;
3675    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
3676    if(!rsrcSetList->list.array)
3677    {
3678       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
3679       return RFAILED;
3680    }
3681
3682    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
3683    {
3684       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
3685       if(!rsrcSetList->list.array[rSetIdx])
3686       {
3687          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
3688          return RFAILED;
3689       }
3690    }
3691
3692    rSetIdx = 0;
3693    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
3694
3695    /* Fill Resource Id list in resource set */
3696    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
3697    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
3698          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
3699    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
3700    {
3701       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
3702       return RFAILED;
3703    }
3704
3705    elementCnt = 1;
3706    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
3707    rsrcIdList->list.count = elementCnt;
3708    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
3709    rsrcIdList->list.array = NULLP;
3710    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
3711    if(!rsrcIdList->list.array)
3712    {
3713       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
3714       return RFAILED;
3715    }
3716
3717    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
3718    {
3719       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
3720       if(!rsrcIdList->list.array[rsrcIdx])
3721       {
3722          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
3723          return RFAILED;
3724       }
3725    }
3726
3727    rsrcIdx = 0;
3728    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
3729
3730    /* Fill resource type */
3731    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
3732                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
3733
3734    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
3735    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
3736          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
3737    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
3738    {
3739       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
3740       return RFAILED;
3741    }
3742    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
3743       = APERIODIC_SRS_RESRC_TRIGGER;
3744
3745    /* TODO : Fill values for below IEs as expected by Viavi */
3746    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
3747    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
3748
3749
3750    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
3751    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
3752    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
3753    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
3754    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
3755
3756    return ROK;
3757 }
3758
3759 /*******************************************************************
3760  *
3761  * @brief Builds BWP UL dedicated SRS Config
3762  *
3763  * @details
3764  *
3765  *    Function : BuildBWPUlDedSrsCfg
3766  *
3767  *    Functionality: Builds BWP UL dedicated SRS Config
3768  *
3769  * @params[in] SRS Config
3770  * @return ROK     - success
3771  *         RFAILED - failure
3772  *
3773  * ****************************************************************/
3774 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
3775 {
3776    srsCfg->srs_ResourceSetToReleaseList = NULLP;
3777    srsCfg->srs_ResourceSetToAddModList = NULLP;
3778    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
3779          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
3780    if(!srsCfg->srs_ResourceSetToAddModList)
3781    {
3782       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
3783       return RFAILED;
3784    }
3785    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
3786    {
3787       return RFAILED;
3788    }
3789
3790    srsCfg->srs_ResourceToReleaseList = NULLP;
3791
3792    /* Resource to Add/Modify list */
3793    srsCfg->srs_ResourceToAddModList = NULLP;
3794    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
3795          sizeof(struct SRS_Config__srs_ResourceToAddModList));
3796    if(!srsCfg->srs_ResourceToAddModList)
3797    {
3798       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
3799       return RFAILED;
3800    }
3801
3802    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
3803    {
3804       return RFAILED;
3805    }
3806
3807    srsCfg->tpc_Accumulation = NULLP;
3808
3809    return ROK;
3810 }
3811
3812
3813
3814 /*******************************************************************
3815  *
3816  * @brief Builds Pusch Serving cell Config
3817  *
3818  * @details
3819  *
3820  *    Function : BuildPuschSrvCellCfg
3821  *
3822  *    Functionality: Builds Pusch Serving cell Config
3823  *
3824  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
3825  *
3826  * @return ROK     - success
3827  *         RFAILED - failure
3828  *
3829  * ****************************************************************/
3830 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
3831 {
3832    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
3833    puschCfg->choice.setup = NULLP;
3834    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
3835    if(!puschCfg->choice.setup)
3836    {
3837       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3838       return RFAILED;
3839    }
3840
3841    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
3842    puschCfg->choice.setup->rateMatching = NULLP;
3843    puschCfg->choice.setup->xOverhead = NULLP;
3844    puschCfg->choice.setup->ext1 = NULLP;
3845    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
3846    if(!puschCfg->choice.setup->ext1)
3847    {
3848       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3849       return RFAILED;
3850    }
3851
3852    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
3853    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
3854    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
3855    {
3856       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3857       return RFAILED;
3858    }
3859    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
3860
3861    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
3862    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
3863    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
3864    {
3865       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3866       return RFAILED;
3867    }
3868    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
3869    return ROK;
3870 }
3871
3872 /*******************************************************************
3873  *
3874  * @brief Builds inital UL BWP
3875  *
3876  * @details
3877  *
3878  *    Function : BuildInitialUlBWP
3879  *
3880  *    Functionality: Builds initial UL BWP
3881  *
3882  * @params[in] BWP_UplinkDedicated_t *ulBwp
3883  * @return ROK     - success
3884  *         RFAILED - failure
3885  *
3886  * ****************************************************************/
3887 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
3888 {
3889    ulBwp->pucch_Config = NULLP;
3890
3891    /* Fill BWP UL dedicated PUSCH config */
3892    ulBwp->pusch_Config = NULLP;
3893    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
3894    if(!ulBwp->pusch_Config)
3895    {
3896       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
3897       return RFAILED;
3898    }
3899
3900    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
3901    ulBwp->pusch_Config->choice.setup = NULLP;
3902    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
3903    if(!ulBwp->pusch_Config->choice.setup)
3904    {
3905       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
3906       return RFAILED;
3907    }
3908
3909    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
3910    {
3911       return RFAILED;
3912    }
3913
3914    ulBwp->configuredGrantConfig = NULLP;
3915
3916    /* Fill BPW UL dedicated SRS config */
3917    ulBwp->srs_Config = NULLP;
3918    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
3919    if(!ulBwp->srs_Config)
3920    {
3921       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
3922       return RFAILED;
3923    }
3924
3925    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
3926    ulBwp->srs_Config->choice.setup = NULLP;
3927    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
3928    if(!ulBwp->srs_Config->choice.setup)
3929    {
3930       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
3931       return RFAILED;
3932    }
3933
3934    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
3935    {
3936       return RFAILED;
3937    }
3938
3939    ulBwp->beamFailureRecoveryConfig = NULLP;
3940
3941    return ROK;
3942 }
3943
3944 /*******************************************************************
3945  *
3946  * @brief Builds UL config
3947  * @details
3948  *
3949  *    Function : BuildUlCfg
3950  *
3951  *    Functionality: Builds UL config in spCellCfgDed
3952  *
3953  * @params[in] UplinkConfig_t *ulCfg
3954  *
3955  * @return ROK     - success
3956  *         RFAILED - failure
3957  *
3958  * ****************************************************************/
3959 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
3960 {
3961    ulCfg->initialUplinkBWP = NULLP;
3962    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
3963    if(!ulCfg->initialUplinkBWP)
3964    {
3965       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
3966       return RFAILED;
3967    }
3968
3969    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
3970    {
3971       return RFAILED;
3972    }
3973
3974    ulCfg->uplinkBWP_ToReleaseList = NULLP;
3975    ulCfg->uplinkBWP_ToAddModList = NULLP;
3976    ulCfg->firstActiveUplinkBWP_Id = NULLP;
3977    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
3978    if(!ulCfg->firstActiveUplinkBWP_Id)
3979    {
3980       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
3981       return RFAILED;
3982    }
3983    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
3984
3985    ulCfg->pusch_ServingCellConfig = NULLP;
3986    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
3987          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
3988    if(!ulCfg->pusch_ServingCellConfig)
3989    {
3990       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
3991       return RFAILED;
3992    }
3993
3994    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
3995    {
3996       return RFAILED;
3997    }
3998
3999    ulCfg->carrierSwitching = NULLP;
4000    ulCfg->ext1 = NULLP;
4001    return ROK;
4002 }
4003
4004 /*******************************************************************
4005  *
4006  * @brief Builds PDSCH serving cell config
4007  * @details
4008  *
4009  *    Function : BuildPdschSrvCellCfg
4010  *
4011  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4012  *
4013  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4014  *
4015  * @return ROK     - success
4016  *         RFAILED - failure
4017  *
4018  * ****************************************************************/
4019 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4020 {
4021    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4022    pdschCfg->choice.setup = NULLP;
4023    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4024    if(!pdschCfg->choice.setup)
4025    {
4026       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4027       return RFAILED;
4028    }
4029
4030    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4031    pdschCfg->choice.setup->xOverhead = NULLP;
4032    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4033    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4034    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4035    {
4036       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4037       return RFAILED;
4038    }
4039    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4040    pdschCfg->choice.setup->pucch_Cell = NULLP;
4041    pdschCfg->choice.setup->ext1 = NULLP;
4042
4043    return ROK;
4044 }
4045
4046 /*******************************************************************
4047  *
4048  * @brief Builds CSI Meas config
4049  * @details
4050  *
4051  *    Function : BuildCsiMeasCfg
4052  *
4053  *    Functionality: Builds CSI Meas config in spCellCfgDed
4054  *
4055  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4056  *
4057  * @return ROK     - success
4058  *         RFAILED - failure
4059  *
4060  * ****************************************************************/
4061 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4062 {
4063
4064    return ROK;
4065 }
4066
4067 /*******************************************************************
4068  *
4069  * @brief Builds Spcell config dedicated
4070  * @details
4071  *
4072  *    Function : BuildSpCellCfgDed
4073  *
4074  *    Functionality: Builds sp cell config dedicated in spCellCfg
4075  *
4076  * @params[in] ServingCellConfig_t srvCellCfg
4077  *
4078  * @return ROK     - success
4079  *         RFAILED - failure
4080  *
4081  * ****************************************************************/
4082 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4083 {
4084    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4085    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4086    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4087    {
4088       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4089       return RFAILED;
4090    }
4091
4092    srvCellCfg->initialDownlinkBWP = NULLP;
4093    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4094    if(!srvCellCfg->initialDownlinkBWP)
4095    {
4096       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4097       return RFAILED;
4098    }
4099
4100    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4101    {
4102       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4103       return RFAILED;
4104    }
4105    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4106    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4107
4108    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4109    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4110    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4111    {
4112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4113       return RFAILED;
4114    }
4115    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4116
4117    srvCellCfg->bwp_InactivityTimer = NULLP;
4118
4119    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4120    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4121    if(!srvCellCfg->defaultDownlinkBWP_Id)
4122    {
4123       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4124       return RFAILED;
4125    }
4126    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4127
4128    srvCellCfg->uplinkConfig = NULLP;
4129    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4130    if(!srvCellCfg->uplinkConfig)
4131    {
4132       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4133       return RFAILED;
4134    }
4135
4136    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4137    {
4138       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4139       return RFAILED;
4140    }
4141    srvCellCfg->supplementaryUplink = NULLP;
4142    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4143
4144    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4145    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4146    if(!srvCellCfg->pdsch_ServingCellConfig)
4147    {
4148       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4149       return RFAILED;
4150    }
4151
4152    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4153    {
4154       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4155       return RFAILED;
4156    }
4157
4158    srvCellCfg->csi_MeasConfig = NULLP;
4159 #if 0
4160    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4161       if(!srvCellCfg->csi_MeasConfig)
4162       {
4163          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4164          return RFAILED;
4165       }
4166
4167    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4168    {
4169       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4170       return RFAILED;
4171    }
4172 #endif
4173    srvCellCfg->sCellDeactivationTimer = NULLP;
4174    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4175    srvCellCfg->tag_Id = TAG_ID;
4176    srvCellCfg->dummy = NULLP;
4177    srvCellCfg->pathlossReferenceLinking = NULLP;
4178    srvCellCfg->servingCellMO = NULLP;
4179    srvCellCfg->ext1 = NULLP;
4180
4181    return ROK;
4182 }
4183 /*******************************************************************
4184  *
4185  * @brief Builds Spcell config
4186  *
4187  * @details
4188  *
4189  *    Function : BuildSpCellCfg
4190  *
4191  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4192  *
4193  * @params[in] SpCellConfig_t spCellCfg
4194  *
4195  * @return ROK     - success
4196  *         RFAILED - failure
4197  *
4198  * ****************************************************************/
4199 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4200 {
4201
4202    spCellCfg->servCellIndex = NULLP;
4203    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4204    if(!spCellCfg->servCellIndex)
4205    {
4206       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4207       return RFAILED;
4208    }
4209    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4210
4211    spCellCfg->reconfigurationWithSync = NULLP;
4212    spCellCfg->rlf_TimersAndConstants = NULLP;
4213    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4214    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4215    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4216    {
4217       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4218       return RFAILED;
4219    }
4220    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4221
4222    spCellCfg->spCellConfigDedicated = NULLP;
4223    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4224    if(!spCellCfg->spCellConfigDedicated)
4225    {
4226       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4227       return RFAILED;
4228    }
4229    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4230    {
4231       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4232       return RFAILED;
4233    }
4234    return ROK;
4235 }
4236 /*******************************************************************
4237  *
4238  * @brief Builds Phy cell group config
4239  *
4240  * @details
4241  *
4242  *    Function : BuildPhyCellGrpCfg
4243  *
4244  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4245  *
4246  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4247  *
4248  * @return ROK     - success
4249  *         RFAILED - failure
4250  *
4251  * ****************************************************************/
4252 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4253 {
4254    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4255    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4256
4257    phyCellGrpCfg->p_NR_FR1 = NULLP;
4258    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4259    if(!phyCellGrpCfg->p_NR_FR1)
4260    {
4261       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4262       return RFAILED;
4263    }
4264    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4265    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4266    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4267    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4268    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4269    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4270    phyCellGrpCfg->cs_RNTI = NULLP;
4271    phyCellGrpCfg->ext1 = NULLP;
4272    phyCellGrpCfg->ext2 = NULLP;
4273
4274    return ROK;
4275 }
4276 /*******************************************************************
4277  *
4278  * @brief Builds Mac cell group config
4279  *
4280  * @details
4281  *
4282  *    Function : BuildMacCellGrpCfg
4283  *
4284  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4285  *
4286  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4287  *
4288  * @return ROK     - success
4289  *         RFAILED - failure
4290  *
4291  * ****************************************************************/
4292 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4293 {
4294    macCellGrpCfg->drx_Config = NULLP;
4295    macCellGrpCfg->schedulingRequestConfig = NULLP;
4296    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4297    if(!macCellGrpCfg->schedulingRequestConfig)
4298    {
4299       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4300       return RFAILED;
4301    }
4302
4303    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4304    {
4305       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
4306       return RFAILED;
4307    }
4308
4309    macCellGrpCfg->bsr_Config = NULLP;
4310    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4311    if(!macCellGrpCfg->bsr_Config)
4312    {
4313       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4314       return RFAILED;
4315    }
4316
4317    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4318    {
4319       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
4320       return RFAILED;
4321    }
4322
4323    macCellGrpCfg->tag_Config = NULLP;
4324    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4325    if(!macCellGrpCfg->tag_Config)
4326    {
4327       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4328       return RFAILED;
4329    }
4330
4331    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4332    {
4333       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
4334       return RFAILED;
4335    }
4336
4337    macCellGrpCfg->phr_Config = NULLP;
4338    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4339    if(!macCellGrpCfg->phr_Config)
4340    {
4341       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4342       return RFAILED;
4343    }
4344
4345    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4346    {
4347       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
4348       return RFAILED;
4349    }
4350
4351    macCellGrpCfg->skipUplinkTxDynamic = false;
4352    macCellGrpCfg->ext1 = NULLP;
4353
4354    return ROK;
4355 }
4356 /*******************************************************************
4357  *
4358  * @brief Frees memeory allocated for SearchSpcToAddModList
4359  *
4360  * @details
4361  *
4362  *    Function : FreeSearchSpcToAddModList
4363  *
4364  *    Functionality: Deallocating memory of SearchSpcToAddModList
4365  *
4366  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4367  *
4368  * @return void
4369  *
4370  4221 * ****************************************************************/
4371 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4372 {
4373    uint8_t idx1=0;
4374    uint8_t idx2=0;
4375    struct  SearchSpace *searchSpc=NULLP;
4376
4377    if(searchSpcList->list.array)
4378    {
4379       if(searchSpcList->list.array[idx2])
4380       {
4381          searchSpc = searchSpcList->list.array[idx2];
4382          if(searchSpc->controlResourceSetId)
4383          {
4384             if(searchSpc->monitoringSlotPeriodicityAndOffset)
4385             {
4386                if(searchSpc->monitoringSymbolsWithinSlot)
4387                {
4388                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
4389                   {
4390                      if(searchSpc->nrofCandidates)
4391                      {
4392                         if(searchSpc->searchSpaceType)
4393                         {
4394                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4395                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4396                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
4397                                     SearchSpace__searchSpaceType));
4398                         }
4399                         DU_FREE(searchSpc->nrofCandidates,
4400                               sizeof(struct SearchSpace__nrofCandidates));
4401                      }
4402                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4403                            searchSpc->monitoringSymbolsWithinSlot->size);
4404                   }
4405                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4406                         sizeof(BIT_STRING_t));
4407                }
4408                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4409                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4410             }
4411             DU_FREE(searchSpc->controlResourceSetId,
4412                   sizeof(ControlResourceSetId_t));
4413          }
4414       }
4415       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4416       {
4417          DU_FREE(searchSpcList->list.array[idx1],
4418                sizeof(struct SearchSpace));
4419       }
4420       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4421    }
4422 }
4423 /*******************************************************************
4424  *
4425  * @brief Frees memory allocated for PdschTimeDomAllocList
4426  *
4427  * @details
4428  *
4429  *    Function : FreePdschTimeDomAllocList
4430  *
4431  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4432  *
4433  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4434  *
4435  * @return void
4436  *
4437  4221 * ****************************************************************/
4438 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4439 {
4440    uint8_t idx1=0;
4441
4442    if(timeDomAllocList->choice.setup)
4443    {
4444       if(timeDomAllocList->choice.setup->list.array)
4445       {
4446          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4447          {
4448             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4449                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
4450          }
4451          DU_FREE(timeDomAllocList->choice.setup->list.array, \
4452                timeDomAllocList->choice.setup->list.size);
4453       }
4454       DU_FREE(timeDomAllocList->choice.setup,\
4455             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4456    }
4457 }
4458 /*******************************************************************
4459  *
4460  * @brief Frees memory allocated for PuschTimeDomAllocList
4461  *
4462  *@details
4463  *
4464  *    Function : FreePuschTimeDomAllocList
4465  *
4466  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4467  *
4468  * @params[in] PUSCH_Config_t *puschCfg
4469  *
4470  * @return void
4471  *
4472  * ****************************************************************/
4473 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4474 {
4475    uint8_t idx1=0;
4476    uint8_t idx2=0;
4477    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4478
4479    if(puschCfg->pusch_TimeDomainAllocationList)
4480    {
4481       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4482       if(timeDomAllocList_t->choice.setup)
4483       {
4484          if(timeDomAllocList_t->choice.setup->list.array)
4485          {
4486             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4487             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4488             {
4489                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4490                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
4491             }
4492             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4493                   timeDomAllocList_t->choice.setup->list.size);
4494          }
4495          DU_FREE(timeDomAllocList_t->choice.setup, \
4496                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4497       }
4498       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
4499       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4500             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4501    }
4502
4503 }
4504 /*******************************************************************
4505  *
4506  * @brief Frees memory allocated for InitialUlBWP
4507  *
4508  * @details
4509  *
4510  *    Function : FreeInitialUlBWP
4511  *
4512  *    Functionality: Deallocating memory of InitialUlBWP
4513  *
4514  * @params[in] BWP_UplinkDedicated_t *ulBwp
4515  *
4516  * @return void
4517  *
4518  * ****************************************************************/
4519 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4520 {
4521    uint8_t  rSetIdx, rsrcIdx;
4522    SRS_Config_t   *srsCfg = NULLP;
4523    PUSCH_Config_t *puschCfg = NULLP;
4524    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
4525    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
4526    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
4527    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
4528
4529    if(ulBwp->pusch_Config)
4530    {
4531       if(ulBwp->pusch_Config->choice.setup)
4532       {
4533          puschCfg=ulBwp->pusch_Config->choice.setup;
4534          if(puschCfg->dataScramblingIdentityPUSCH)
4535          {
4536             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4537             {
4538                FreePuschTimeDomAllocList(puschCfg);
4539                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
4540                if(dmrsUlCfg->choice.setup)
4541                {
4542                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4543                   {
4544                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4545                      {
4546                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4547                               sizeof(long));
4548                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
4549                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4550                      }
4551                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
4552                            sizeof(long));
4553                   }
4554                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
4555                }
4556                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4557                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4558             }
4559             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4560          }
4561          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4562       }
4563       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4564
4565       /* Free SRS-Config */
4566       if(ulBwp->srs_Config)
4567       {
4568          if(ulBwp->srs_Config->choice.setup)
4569          {
4570             srsCfg = ulBwp->srs_Config->choice.setup;
4571
4572             /* Free Resource Set to add/mod list */
4573             if(srsCfg->srs_ResourceSetToAddModList)
4574             {
4575                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
4576                if(rsrcSetList->list.array)
4577                {
4578                   rSetIdx = 0;
4579
4580                   /* Free SRS resource Id list in this SRS resource set */
4581                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4582                   {
4583                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4584
4585                      if(rsrcIdList->list.array)
4586                      {
4587                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4588                         {
4589                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4590                         }
4591                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
4592                      }
4593                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4594                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4595                   }
4596
4597                   /* Free resource type info for this SRS resource set */
4598                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4599                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4600
4601                   /* Free memory for each resource set */
4602                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4603                   {
4604                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4605                   }
4606                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
4607                }
4608                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
4609                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4610             }
4611
4612             /* Free resource to add/modd list */
4613             if(srsCfg->srs_ResourceToAddModList)
4614             {
4615                resourceList = srsCfg->srs_ResourceToAddModList;
4616                if(resourceList->list.array)
4617                {
4618                   rsrcIdx = 0;
4619                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
4620                         sizeof(struct SRS_Resource__transmissionComb__n2));
4621                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
4622                         sizeof(struct SRS_Resource__resourceType__aperiodic));
4623
4624                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4625                   {
4626                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4627                   }
4628                   DU_FREE(resourceList->list.array, resourceList->list.size);
4629                }
4630                DU_FREE(srsCfg->srs_ResourceToAddModList, \
4631                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
4632             }
4633
4634             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4635          }
4636          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4637       }
4638    }
4639 }
4640 /*******************************************************************
4641  *
4642  * @brief Frees memory allocated for initialUplinkBWP
4643  *
4644  * @details
4645  *
4646  *    Function : FreeinitialUplinkBWP
4647  *
4648  *    Functionality: Deallocating memory of initialUplinkBWP
4649  *
4650  * @params[in] UplinkConfig_t *ulCfg
4651  *
4652  * @return void
4653  *
4654  *
4655  * ****************************************************************/
4656 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
4657 {
4658    BWP_UplinkDedicated_t *ulBwp=NULLP;
4659    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
4660
4661    if(ulCfg->initialUplinkBWP)
4662    {
4663       ulBwp=ulCfg->initialUplinkBWP;
4664       if(ulCfg->firstActiveUplinkBWP_Id)
4665       {
4666          if(ulCfg->pusch_ServingCellConfig)
4667          {
4668             puschCfg=ulCfg->pusch_ServingCellConfig;
4669             if(puschCfg->choice.setup)
4670             {
4671                if(puschCfg->choice.setup->ext1)
4672                {
4673                   DU_FREE(puschCfg->choice.setup->ext1->\
4674                         processingType2Enabled,sizeof(BOOLEAN_t));
4675                   DU_FREE(puschCfg->choice.setup->ext1->\
4676                         maxMIMO_Layers,sizeof(long));
4677                   DU_FREE(puschCfg->choice.setup->ext1, \
4678                         sizeof(struct PUSCH_ServingCellConfig__ext1));
4679                }
4680                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4681             }
4682             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4683          }
4684          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4685       }
4686       FreeInitialUlBWP(ulBwp);
4687       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4688    }
4689 }
4690 /*******************************************************************
4691  *
4692  * @brief Frees emmory allocated for BWPDlDedPdschCfg
4693  *
4694  * @details
4695  *
4696  *    Function : FreeBWPDlDedPdschCfg
4697  *
4698  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
4699  *
4700  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4701  *
4702  * @return void
4703  *
4704  *
4705  * ****************************************************************/
4706 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
4707 {
4708    struct PDSCH_Config *pdschCfg=NULLP;
4709    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
4710    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
4711    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
4712
4713    if(dlBwp->pdsch_Config->choice.setup)
4714    {
4715       pdschCfg=dlBwp->pdsch_Config->choice.setup;
4716       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4717       {
4718          if(pdschCfg->pdsch_TimeDomainAllocationList)
4719          {
4720             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
4721             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
4722             {
4723                prbBndlType=&pdschCfg->prb_BundlingType;
4724                DU_FREE(prbBndlType->choice.staticBundling,\
4725                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4726                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4727             }
4728             FreePdschTimeDomAllocList(timeDomAllocList);
4729             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
4730                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4731          }
4732          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
4733          if(dmrsDlCfg->choice.setup)
4734          {
4735             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
4736                   sizeof(long));
4737             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
4738          }
4739          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4740                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4741       }
4742       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4743    }
4744 }
4745 /*******************************************************************
4746  *
4747  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
4748  *
4749  * @details
4750  *
4751  *    Function : FreeBWPDlDedPdcchCfg
4752  *
4753  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
4754  *
4755  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4756  *
4757  * @return void
4758  *
4759  *
4760  * ****************************************************************/
4761 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
4762 {
4763    uint8_t idx1=0;
4764    uint8_t idx2=0;
4765    struct PDCCH_Config *pdcchCfg=NULLP;
4766    struct ControlResourceSet *controlRSet=NULLP;
4767    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
4768
4769    if(dlBwp->pdcch_Config->choice.setup)
4770    {
4771       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
4772       if(pdcchCfg->controlResourceSetToAddModList)
4773       {
4774          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
4775          if(controlRSetList->list.array)
4776          {
4777             controlRSet = controlRSetList->list.array[idx2];
4778             if(controlRSet)
4779             {
4780                if(controlRSet->frequencyDomainResources.buf)
4781                {
4782                   if(controlRSet->pdcch_DMRS_ScramblingID)
4783                   {
4784                      if(pdcchCfg->searchSpacesToAddModList)
4785                      {
4786                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
4787                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
4788                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
4789                      }
4790                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
4791                   }
4792                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
4793                         controlRSet->frequencyDomainResources.size);
4794                }
4795             }
4796             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
4797             {
4798                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
4799             }
4800             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
4801          }
4802          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
4803                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
4804       }
4805       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4806    }
4807 }
4808
4809 /*******************************************************************
4810  *
4811  * @brief Frees emmory allocated for DUToCURRCContainer
4812  *
4813  * @details
4814  *
4815  *    Function : FreeMemDuToCuRrcCont
4816  *
4817  *    Functionality: Deallocating memory of DuToCuRrcContainer
4818  *
4819  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
4820  *
4821  * @return ROK     - success
4822  *         RFAILED - failure
4823  *
4824  * ****************************************************************/
4825 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
4826 {
4827    uint8_t idx=0;
4828    SpCellConfig_t *spCellCfg=NULLP;
4829    ServingCellConfig_t *srvCellCfg=NULLP;
4830    BWP_DownlinkDedicated_t *dlBwp=NULLP;
4831    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
4832    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
4833    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
4834    struct RLC_Config *rlcConfig=NULLP;
4835    struct LogicalChannelConfig *macLcConfig=NULLP;
4836    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
4837    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
4838    struct TAG_Config *tagConfig=NULLP;
4839    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
4840    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
4841    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
4842
4843    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
4844    if(rlcBearerList)
4845    {
4846       if(rlcBearerList->list.array)
4847       {
4848          for(idx=0; idx<rlcBearerList->list.count; idx++)
4849          {
4850             if(rlcBearerList->list.array[idx])
4851             {
4852                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
4853                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
4854                if(rlcConfig)
4855                {
4856                   if(rlcConfig->choice.am)
4857                   {
4858                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
4859                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
4860                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
4861                   }
4862                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
4863                }
4864                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
4865                if(macLcConfig)
4866                {
4867                   if(macLcConfig->ul_SpecificParameters)
4868                   {
4869                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
4870                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
4871                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
4872                   }
4873                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
4874                }
4875                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
4876             }
4877          }
4878          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
4879       }
4880       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
4881    }
4882
4883    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
4884    if(macCellGrpCfg)
4885    {
4886       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
4887       if(schedulingRequestConfig)
4888       {
4889          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
4890          if(schReqList)
4891          {
4892             if(schReqList->list.array)
4893             {
4894                for(idx=0;idx<schReqList->list.count; idx++)
4895                {
4896                   if(schReqList->list.array[idx])
4897                   {
4898                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
4899                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
4900                   }
4901                }
4902                DU_FREE(schReqList->list.array, schReqList->list.size);
4903             }
4904             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
4905                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
4906             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4907       }
4908       if(macCellGrpCfg->bsr_Config)
4909       {
4910          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4911       }
4912       tagConfig = macCellGrpCfg->tag_Config;
4913       if(tagConfig)
4914       {
4915          tagList = tagConfig->tag_ToAddModList;
4916          if(tagList)
4917          {
4918             if(tagList->list.array)
4919             {
4920                for(idx=0; idx<tagList->list.count; idx++)
4921                {
4922                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
4923                }
4924                DU_FREE(tagList->list.array, tagList->list.size);
4925             }
4926             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
4927          }
4928          DU_FREE(tagConfig, sizeof(struct TAG_Config));
4929       }
4930
4931       phrConfig = macCellGrpCfg->phr_Config;
4932       if(phrConfig)
4933       {
4934          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
4935          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
4936       }
4937
4938       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
4939    }
4940
4941    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
4942    if(phyCellGrpCfg)
4943    {
4944       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4945       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
4946    }
4947
4948    spCellCfg = cellGrpCfg->spCellConfig;
4949    if(spCellCfg)
4950    {
4951       if(spCellCfg->servCellIndex)
4952       {
4953          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
4954          {
4955             if(spCellCfg->spCellConfigDedicated)
4956             {
4957                srvCellCfg = spCellCfg->spCellConfigDedicated;
4958                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4959                {
4960                   if(srvCellCfg->initialDownlinkBWP)
4961                   {
4962                      dlBwp = srvCellCfg->initialDownlinkBWP;
4963                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
4964                      {
4965                         if(srvCellCfg->defaultDownlinkBWP_Id)
4966                         {
4967                            if(srvCellCfg->uplinkConfig)
4968                            {
4969                               if(srvCellCfg->pdsch_ServingCellConfig)
4970                               {
4971                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
4972                                  if(pdschCfg->choice.setup)
4973                                  {
4974                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
4975                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4976                                  }
4977                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
4978                                        ServingCellConfig__pdsch_ServingCellConfig));
4979                               }
4980                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
4981                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4982                            }
4983                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4984                         }
4985                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4986                      }
4987                      if(dlBwp->pdcch_Config)
4988                      {
4989                         if(dlBwp->pdsch_Config)
4990                         {
4991                            FreeBWPDlDedPdschCfg(dlBwp);
4992                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4993                         }
4994                         FreeBWPDlDedPdcchCfg(dlBwp);
4995                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4996                     }
4997                     DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4998                   }
4999                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5000                }
5001                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5002             }
5003             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5004          }
5005          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5006       }
5007       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5008    }
5009    return ROK;
5010 }
5011 /*******************************************************************
5012  *
5013  * @brief Builds DU To CU RRC Container
5014  *
5015  * @details
5016  *
5017  *    Function : BuildDuToCuRrcContainer
5018  *
5019  *    Functionality: Builds DuToCuRrcContainer
5020  *
5021  * @params[in] idx, index in F1AP msg
5022  *             DuToCuRRCContainer, DuToCuRRCContainer
5023  *
5024  * @return ROK     - success
5025  *         RFAILED - failure
5026  *
5027  * ****************************************************************/
5028 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5029 {
5030    uint8_t  ret = ROK;
5031    CellGroupConfigRrc_t  cellGrpCfg;
5032    asn_enc_rval_t        encRetVal;
5033    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5034    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5035
5036    while(true)
5037    {
5038       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5039
5040       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5041       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5042       if(!cellGrpCfg.rlc_BearerToAddModList)
5043       {
5044          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5045          ret = RFAILED;
5046          break;
5047       }
5048       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5049       {
5050          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5051          ret = RFAILED;
5052          break;
5053       }
5054
5055       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5056       cellGrpCfg.mac_CellGroupConfig = NULLP;
5057       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5058       if(!cellGrpCfg.mac_CellGroupConfig)
5059       {
5060          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5061          ret = RFAILED;
5062          break;
5063       }
5064       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5065       {
5066          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5067          ret = RFAILED;
5068          break;
5069       }
5070
5071       cellGrpCfg.physicalCellGroupConfig = NULLP;
5072       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5073       if(!cellGrpCfg.physicalCellGroupConfig)
5074       {
5075          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5076          ret = RFAILED;
5077          break;
5078       }
5079       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5080       {
5081          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5082          ret = RFAILED;
5083          break;
5084       }
5085
5086       cellGrpCfg.spCellConfig = NULLP;
5087       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5088       if(!cellGrpCfg.spCellConfig)
5089       {
5090          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5091          ret = RFAILED;
5092          break;
5093       }
5094       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5095       {
5096          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5097          ret = RFAILED;
5098          break;
5099       }
5100
5101       cellGrpCfg.sCellToAddModList = NULLP;
5102       cellGrpCfg.sCellToReleaseList = NULLP;
5103       cellGrpCfg.ext1 = NULLP;
5104
5105       /* encode cellGrpCfg into duToCuRrcContainer */
5106       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5107       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5108       encBufSize = 0;
5109       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5110       /* Encode results */
5111       if(encRetVal.encoded == ENCODE_FAIL)
5112       {
5113          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5114                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5115          ret = RFAILED;
5116          break;
5117       }
5118       else
5119       {
5120          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5121          for(int i=0; i< encBufSize; i++)
5122          {
5123             printf("%x",encBuf[i]);
5124          }
5125       }
5126
5127       duToCuRrcContainer->size = encBufSize;
5128       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5129       if(!duToCuRrcContainer->buf)
5130       {
5131          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5132          ret = RFAILED;
5133          break;
5134       }
5135       if(ret == ROK)
5136       {
5137          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5138       }
5139       break;
5140    }
5141    FreeMemDuToCuRrcCont(&cellGrpCfg);
5142    return ret;
5143 }
5144
5145 /*******************************************************************
5146  *
5147  * @brief Free memory allocated in InitialULRRCMessage
5148  *
5149  * @details
5150  *
5151  *    Function : freeInitUlRrcMsgTransfer
5152  *
5153  *    Functionality: Free memory allocated in InitialULRRCMessage
5154  *
5155  * @params[in]F1AP_PDU_t  *f1apMsg)
5156  *
5157  * @return ROK     - success
5158  *         RFAILED - failure
5159  *
5160  * ****************************************************************/
5161
5162 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5163 {
5164    uint8_t ieIdx, arrIdx;
5165    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5166
5167    if(f1apMsg)
5168    {
5169       if(f1apMsg->choice.initiatingMessage)
5170       {
5171          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5172             choice.InitialULRRCMessageTransfer;
5173          if(initULRRCMsg->protocolIEs.list.array)
5174          {
5175             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5176             {
5177                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5178                {
5179                   case ProtocolIE_ID_id_NRCGI:
5180                   {
5181                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5182                      {
5183                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5184                         {
5185                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5186                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5187                         }
5188                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5189                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5190                      }
5191                      break;
5192                   }
5193                   case ProtocolIE_ID_id_RRCContainer:
5194                   {
5195                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5196                      {
5197                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5198                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5199                      }
5200                      break;
5201                   }
5202                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5203                   {
5204                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5205                      {
5206                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5207                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5208                      }
5209                      break;
5210                   }
5211                   default:
5212                      break;
5213                }
5214              }
5215              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
5216              {
5217                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
5218                 {
5219                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
5220                       sizeof(InitialULRRCMessageTransferIEs_t));
5221                 }
5222              }
5223              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
5224           }
5225          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5226       }
5227       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5228    }
5229    else
5230    {
5231       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
5232       return RFAILED;
5233    }
5234    return ROK;
5235 }
5236
5237 /*******************************************************************
5238  *
5239  * @brief Builds and sends the InitialULRRCMessage
5240  *
5241  * @details
5242  *
5243  *    Function : BuildAndSendInitialRrcMsgTransfer
5244  *
5245  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
5246  *                   it to the CU through SCTP.
5247  *
5248  * @params[in]
5249  *
5250  * @return ROK     - success
5251  *         RFAILED - failure
5252  *
5253  * ****************************************************************/
5254 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
5255       uint16_t rrcContSize, uint8_t *rrcContainer)
5256 {
5257    uint8_t   ret;
5258    uint8_t   elementCnt;
5259    uint8_t   ieIdx;
5260    asn_enc_rval_t  encRetVal;
5261    F1AP_PDU_t  *f1apMsg = NULLP;
5262    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
5263    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5264
5265    while(true)
5266    {
5267       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
5268       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5269       if(f1apMsg == NULLP)
5270       {
5271          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
5272          break;
5273       }
5274       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5275       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5276       if(f1apMsg->choice.initiatingMessage == NULLP)
5277       {
5278          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
5279          break;
5280       }
5281       f1apMsg->choice.initiatingMessage->procedureCode =\
5282                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
5283       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5284       f1apMsg->choice.initiatingMessage->value.present = \
5285                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5286       initULRRCMsg =\
5287                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5288       elementCnt = 5;
5289       initULRRCMsg->protocolIEs.list.count = elementCnt;
5290       initULRRCMsg->protocolIEs.list.size = \
5291                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5292       /* Initialize the F1Setup members */
5293       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5294       if(initULRRCMsg->protocolIEs.list.array == NULLP)
5295       {
5296          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
5297                RRCSetupRequestMessageTransferIEs failed");
5298          break;
5299       }
5300       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
5301       {
5302          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
5303                sizeof(InitialULRRCMessageTransferIEs_t));
5304          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
5305          {
5306             break;
5307          }
5308       }
5309       ieIdx = 0;
5310       /*GNB DU UE F1AP ID*/
5311       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5312                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5313       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
5314       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5315                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5316       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5317
5318
5319       /*NRCGI*/
5320       ieIdx++;
5321       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5322                                                         ProtocolIE_ID_id_NRCGI;
5323       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
5324       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5325                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5326
5327       ret =\
5328            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
5329       if(ret!=ROK)
5330       {
5331          break;
5332       }
5333
5334       /*CRNTI*/
5335       ieIdx++;
5336       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5337                                                         ProtocolIE_ID_id_C_RNTI;
5338       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5339       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5340                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
5341       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
5342
5343       /*RRCContainer*/
5344       ieIdx++;
5345       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5346                                                         ProtocolIE_ID_id_RRCContainer;
5347       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5348       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5349                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
5350
5351       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
5352       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
5353             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
5354       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5355       {
5356          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
5357          break;
5358
5359       }
5360       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
5361             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5362
5363
5364       /*DUtoCURRCContainer*/
5365       ieIdx++;
5366       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
5367       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5368       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5369                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
5370
5371       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
5372       if(ret != ROK)
5373       {
5374          break;
5375       }
5376
5377       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5378
5379       /* Encode the F1SetupRequest type as APER */
5380       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5381       encBufSize = 0;
5382       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
5383       /* Encode results */
5384       if(encRetVal.encoded == ENCODE_FAIL)
5385       {
5386          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
5387                structure (at %s)\n",encRetVal.failed_type ? \
5388                encRetVal.failed_type->name : "unknown");
5389          ret = RFAILED;
5390          break;
5391       }
5392       else
5393       {
5394
5395          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
5396                Message transfer\n");
5397          for(int i=0; i< encBufSize; i++)
5398          {
5399             printf("%x",encBuf[i]);
5400          }
5401       }
5402       /* Sending  msg  */
5403       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
5404       {
5405          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
5406          ret = RFAILED;
5407          break;
5408       }
5409       break;
5410    }
5411    freeInitUlRrcMsgTransfer(f1apMsg);
5412    return ret;
5413 }/* End of BuildAndSendInitialRrcMsgTransfer*/
5414
5415 /*****  UE SETUP REQUEST *****/
5416
5417 /*******************************************************************
5418  *
5419  * @brief Free Qos And Snssai Drb Info
5420  *
5421  * @details
5422  *
5423  *    Function : freeDrbQosAndSnssaiInfo
5424  *
5425  *    Functionality: Free Qos And Snssai Drb Info
5426  *
5427  * @params[in] LcCfg *lcCfg,
5428  * @return void
5429  *
5430  * ****************************************************************/
5431 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
5432 {
5433    if(lcCfg->snssai)
5434    {
5435       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
5436    }
5437    if(lcCfg->drbQos)
5438    {
5439       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
5440    }
5441 }
5442
5443 /******************************************************************
5444 *
5445 * @brief Function to delete the RLC Lc cfg from UE APP DB
5446 *
5447 * @details
5448 *
5449 *  Function : freeRlcLcCfg
5450 *
5451 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
5452 *
5453 *
5454  *****************************************************************/
5455
5456 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
5457 {
5458    switch(lcCfg->rlcMode)
5459    {
5460       case RLC_AM :
5461       {
5462          if(lcCfg->u.amCfg)
5463          {
5464             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
5465             lcCfg->u.amCfg = NULLP;
5466          }
5467          break;
5468       }
5469       case RLC_UM_BI_DIRECTIONAL :
5470       {
5471          if(lcCfg->u.umBiDirCfg)
5472          {
5473             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
5474             lcCfg->u.umBiDirCfg = NULLP;
5475          }
5476          break;
5477       }
5478       case RLC_UM_UNI_DIRECTIONAL_UL :
5479       {
5480          if(lcCfg->u.umUniDirUlCfg)
5481          {
5482             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
5483             lcCfg->u.umUniDirUlCfg = NULLP;
5484          }
5485          break;
5486
5487       }
5488       case RLC_UM_UNI_DIRECTIONAL_DL :
5489       {
5490          if(lcCfg->u.umUniDirDlCfg)
5491          {
5492             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
5493             lcCfg->u.umUniDirDlCfg = NULLP;
5494          }
5495          break;
5496       }
5497       default:
5498          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
5499          break;
5500    }
5501    memset(lcCfg, 0, sizeof(LcCfg));
5502 }
5503 /*******************************************************************
5504  *
5505  * @brief Function to free MacLcCfg
5506  *
5507  * @details
5508  *
5509  *    Function : freeMacLcCfg
5510  *
5511  *    Functionality: Function to free MacLcCfg
5512  *
5513  * @params[in] LcCfg *lcCfg,
5514  * @return void
5515  *
5516  * ****************************************************************/
5517
5518 void  freeMacLcCfg(LcCfg *lcCfg)
5519 {
5520     /* Deleting DRBQOS */
5521    if(lcCfg->drbQos)
5522    {
5523       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
5524       lcCfg->drbQos = NULLP;
5525    }
5526    /* Deleting SNSSAI */
5527    if(lcCfg->snssai)
5528    {
5529       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
5530       lcCfg->snssai = NULLP;
5531    }
5532    memset(lcCfg, 0, sizeof(LcCfg));
5533 }
5534 /*******************************************************************
5535  *
5536  * @brief Free UE NR Capability received in UE Context setup request
5537  *
5538  * @details
5539  *
5540  *    Function : freeAperDecodeUeNrCapability
5541  *
5542  *    Functionality:
5543  *       Free UE NR Capability received in UE Context setup request
5544  *
5545  * @params[in]
5546  * @return ROK     - success
5547  *         RFAILED - failure
5548  *
5549  * ****************************************************************/
5550 void freeAperDecodeUeNrCapability(void *ueNrCapability)
5551 {
5552    uint8_t arrIdx =0;
5553    FeatureSets_t *featureSets =NULLP;
5554    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
5555
5556    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
5557    {
5558       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
5559       {
5560          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
5561             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
5562       }
5563       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
5564    }
5565
5566    if(ueNrCap->featureSets)
5567    {
5568       featureSets = ueNrCap->featureSets;
5569       if(featureSets->featureSetsDownlinkPerCC)
5570       {
5571          if(featureSets->featureSetsDownlinkPerCC->list.array)
5572          {
5573             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
5574             {
5575                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
5576                {
5577                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
5578                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
5579                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
5580                }
5581             }
5582             free(featureSets->featureSetsDownlinkPerCC->list.array);
5583          }
5584          free(featureSets->featureSetsDownlinkPerCC);
5585       }
5586       if(featureSets->featureSetsUplinkPerCC)
5587       {
5588          if(featureSets->featureSetsUplinkPerCC->list.array)
5589          {
5590             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
5591             {
5592                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
5593                {
5594                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
5595                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
5596                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
5597                }
5598             }
5599             free(featureSets->featureSetsUplinkPerCC->list.array);
5600          }
5601          free(featureSets->featureSetsUplinkPerCC);
5602       }
5603       free(ueNrCap->featureSets);
5604    }
5605 }
5606
5607 /*******************************************************************
5608 *
5609 * @brief Function to free PdcchSearchSpcToAddModList
5610          where memory allocated by aper_decoder
5611 *
5612 * @details
5613 *
5614 *    Function : freeAperDecodePdcchSearchSpcToAddModList
5615 *
5616 *    Functionality: Function to free PdcchSearchSpcToAddModList
5617 *
5618 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5619 * @return void
5620 *
5621 * ****************************************************************/
5622
5623 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5624 {
5625    uint8_t searchSpcArrIdx=0;
5626    uint8_t searchSpcArrIdx1=0;
5627    struct  SearchSpace *searchSpc=NULLP;
5628
5629
5630    if(searchSpcList->list.array)
5631    {
5632       if(searchSpcList->list.array[searchSpcArrIdx1])
5633       {
5634          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
5635          if(searchSpc->controlResourceSetId)
5636          {
5637             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5638             {
5639                if(searchSpc->monitoringSymbolsWithinSlot)
5640                {
5641                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5642                   {
5643                      if(searchSpc->nrofCandidates)
5644                      {
5645                         if(searchSpc->searchSpaceType)
5646                         {
5647                            free(searchSpc->searchSpaceType->choice.ue_Specific);
5648                            free(searchSpc->searchSpaceType);
5649                         }
5650                         free(searchSpc->nrofCandidates);
5651                      }
5652                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
5653                   }
5654                   free(searchSpc->monitoringSymbolsWithinSlot);
5655                }
5656                free(searchSpc->monitoringSlotPeriodicityAndOffset);
5657             }
5658             free(searchSpc->controlResourceSetId);
5659          }
5660       }
5661       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
5662       {
5663          free(searchSpcList->list.array[searchSpcArrIdx]);
5664       }
5665       free(searchSpcList->list.array);
5666    }
5667 }
5668 /*******************************************************************
5669 *
5670 * @brief Function for free part for the memory allocated by aper_decoder
5671 *
5672 * @details
5673 *
5674 *    Function : freeAperDecodeBWPDlDedPdcchConfig
5675 *
5676 *    Functionality: Function to free BWPDlDedPdcchConfig
5677 *
5678 * @params[in]
5679 * @return void
5680 *
5681 * ****************************************************************/
5682
5683
5684 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
5685 {
5686    uint8_t arrIdx1=0;
5687    uint8_t arrIdx2=0;
5688    struct PDCCH_Config *pdcchCfg=NULLP;
5689    struct ControlResourceSet *controlRSet=NULLP;
5690    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5691
5692    if(dlBwp->pdcch_Config->choice.setup)
5693    {
5694       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5695       if(pdcchCfg->controlResourceSetToAddModList)
5696       {
5697          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5698          if(controlRSetList->list.array)
5699          {
5700             controlRSet = controlRSetList->list.array[arrIdx2];
5701             if(controlRSet)
5702             {
5703                if(controlRSet->frequencyDomainResources.buf)
5704                {
5705                   if(controlRSet->pdcch_DMRS_ScramblingID)
5706                   {
5707                      if(pdcchCfg->searchSpacesToAddModList)
5708                      {
5709                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5710                         free(pdcchCfg->searchSpacesToAddModList);
5711                      }
5712                      free(controlRSet->pdcch_DMRS_ScramblingID);
5713                   }
5714                   free(controlRSet->frequencyDomainResources.buf);
5715                }
5716             }
5717             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
5718             {
5719                free(controlRSetList->list.array[arrIdx1]);
5720             }
5721             free(controlRSetList->list.array);
5722          }
5723          free(pdcchCfg->controlResourceSetToAddModList);
5724       }
5725       free(dlBwp->pdcch_Config->choice.setup);
5726    }
5727 }
5728 /*******************************************************************
5729 *
5730 * @brief Function to free PdschTimeDomAllocationList
5731 *     where the memory allocated by aper_decoder
5732 *
5733 * @details
5734 *
5735 *    Function : freeAperDecodePdschTimeDomAllocationList
5736 *
5737 *    Functionality: Function to free PdschTimeDomAllocationList
5738 *
5739 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5740 * @return void
5741 *
5742 * ****************************************************************/
5743
5744
5745 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5746 {
5747    uint8_t arrIdx=0;
5748
5749    if(timeDomAllocList->choice.setup)
5750    {
5751       if(timeDomAllocList->choice.setup->list.array)
5752       {
5753          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
5754          {
5755             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
5756          }
5757          free(timeDomAllocList->choice.setup->list.array);
5758       }
5759       free(timeDomAllocList->choice.setup);
5760    }
5761 }
5762
5763 /*******************************************************************
5764 *
5765 * @brief Function to free BWPDlDedPdschConfig
5766 *        where the memory allocated by aper_decoder
5767 *
5768 * @details
5769 *
5770 *    Function : freeAperDecodeBWPDlDedPdschConfig
5771 *
5772 *    Functionality: Function to free BWPDlDedPdschConfig
5773 *
5774 * @params[in] BWP_DownlinkDedicated_t *dlBwp
5775 * @return void
5776 *
5777 * ****************************************************************/
5778
5779
5780 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
5781 {
5782    struct PDSCH_Config *pdschCfg=NULLP;
5783    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5784    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5785    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5786
5787    if(dlBwp->pdsch_Config->choice.setup)
5788    {
5789       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5790       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5791       {
5792          if(pdschCfg->pdsch_TimeDomainAllocationList)
5793          {
5794             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5795             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5796             {
5797                prbBndlType=&pdschCfg->prb_BundlingType;
5798                free(prbBndlType->choice.staticBundling);
5799                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
5800             }
5801             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
5802             free(pdschCfg->pdsch_TimeDomainAllocationList);
5803          }
5804          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5805          if(dmrsDlCfg->choice.setup)
5806          {
5807             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
5808             free(dmrsDlCfg->choice.setup);
5809          }
5810          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
5811       }
5812       free(dlBwp->pdsch_Config->choice.setup);
5813    }
5814 }
5815 /*******************************************************************
5816 *
5817 * @brief Function to free PuschTimeDomAllocListCfg
5818                  where the memory allocated by aper_decoder
5819 *
5820 * @details
5821 *
5822 *    Function : freeAperDecodePuschTimeDomAllocListCfg
5823 *
5824 *    Functionality: Function to free PuschTimeDomAllocListCfg
5825 *
5826 * @params[in] PUSCH_Config_t *puschCfg
5827 * @return void
5828 *
5829 * ****************************************************************/
5830
5831
5832 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
5833 {
5834    uint8_t arrIdx=0;
5835    uint8_t arrIdx1=0;
5836    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5837
5838    if(puschCfg->pusch_TimeDomainAllocationList)
5839    {
5840       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5841       if(timeDomAllocList_t->choice.setup)
5842       {
5843          if(timeDomAllocList_t->choice.setup->list.array)
5844          {
5845             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
5846             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
5847             {
5848                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
5849             }
5850             free(timeDomAllocList_t->choice.setup->list.array);
5851          }
5852          free(timeDomAllocList_t->choice.setup);
5853       }
5854       free(puschCfg->transformPrecoder);
5855       free(puschCfg->pusch_TimeDomainAllocationList);
5856    }
5857 }
5858 /*******************************************************************
5859 *
5860 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
5861 *
5862 * @details
5863 *
5864 *    Function : freeAperDecodeInitialUlBWPConfig
5865 *
5866 *    Functionality: Function to free InitialUlBWPConfig
5867 *
5868 * @params[in]  BWP_UplinkDedicated_t *ulBwp
5869 * @return void
5870 *
5871 * ****************************************************************/
5872
5873
5874 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
5875 {
5876    uint8_t  rSetIdx =0;
5877    uint8_t  rsrcIdx =0;
5878    SRS_Config_t   *srsCfg = NULLP;
5879    PUSCH_Config_t *puschCfg = NULLP;
5880    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5881    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5882    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5883    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5884
5885    if(ulBwp->pusch_Config)
5886    {
5887       if(ulBwp->pusch_Config->choice.setup)
5888       {
5889          puschCfg=ulBwp->pusch_Config->choice.setup;
5890          if(puschCfg->dataScramblingIdentityPUSCH)
5891          {
5892             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5893             {
5894                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
5895                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5896                if(dmrsUlCfg->choice.setup)
5897                {
5898                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5899                   {
5900                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5901                      {
5902                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
5903                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
5904                      }
5905                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
5906                   }
5907                   free(dmrsUlCfg->choice.setup);
5908                }
5909                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
5910             }
5911             free(puschCfg->dataScramblingIdentityPUSCH);
5912          }
5913          free(ulBwp->pusch_Config->choice.setup);
5914       }
5915       free(ulBwp->pusch_Config);
5916
5917       /* Free SRS-Config */
5918       if(ulBwp->srs_Config)
5919       {
5920          if(ulBwp->srs_Config->choice.setup)
5921          {
5922             srsCfg = ulBwp->srs_Config->choice.setup;
5923
5924             /* Free Resource Set to add/mod list */
5925             if(srsCfg->srs_ResourceSetToAddModList)
5926             {
5927                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5928                if(rsrcSetList->list.array)
5929                {
5930                   rSetIdx = 0;
5931
5932                   /* Free SRS resource Id list in this SRS resource set */
5933                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5934                   {
5935                      rsrcIdList =
5936                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5937
5938                      if(rsrcIdList->list.array)
5939                      {
5940                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
5941                               rsrcIdx++)
5942                         {
5943                            free(rsrcIdList->list.array[rsrcIdx]);
5944                         }
5945                         free(rsrcIdList->list.array);
5946                      }
5947                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
5948                   }
5949
5950                   /* Free resource type info for this SRS resource set */
5951
5952                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
5953
5954                   /* Free memory for each resource set */
5955                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5956                   {
5957                      free(rsrcSetList->list.array[rSetIdx]);
5958                   }
5959                   free(rsrcSetList->list.array);
5960                }
5961                free(srsCfg->srs_ResourceSetToAddModList);
5962             }
5963
5964             /* Free resource to add/modd list */
5965             if(srsCfg->srs_ResourceToAddModList)
5966             {
5967                resourceList = srsCfg->srs_ResourceToAddModList;
5968                if(resourceList->list.array)
5969                {
5970                   rsrcIdx = 0;
5971
5972                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
5973                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
5974
5975                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5976                   {
5977                      free(resourceList->list.array[rsrcIdx]);
5978                   }
5979                   free(resourceList->list.array);
5980                }
5981                free(srsCfg->srs_ResourceToAddModList);
5982             }
5983
5984             free(ulBwp->srs_Config->choice.setup);
5985          }
5986          free(ulBwp->srs_Config);
5987       }
5988    }
5989 }
5990 /*******************************************************************
5991 *
5992 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
5993 *
5994 * @details
5995 *
5996 *    Function : freeAperDecodeinitialUplinkBWPConfig
5997 *
5998 *    Functionality: Function to free initialUplinkBWPConfig
5999 *
6000 * @params[in] UplinkConfig_t *ulCfg
6001 * @return void
6002 *
6003 * ****************************************************************/
6004
6005
6006 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6007 {
6008    BWP_UplinkDedicated_t *ulBwp=NULLP;
6009    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6010
6011    if(ulCfg->initialUplinkBWP)
6012    {
6013       ulBwp=ulCfg->initialUplinkBWP;
6014       if(ulCfg->firstActiveUplinkBWP_Id)
6015       {
6016          if(ulCfg->pusch_ServingCellConfig)
6017          {
6018             puschCfg=ulCfg->pusch_ServingCellConfig;
6019             if(puschCfg->choice.setup)
6020             {
6021                if(puschCfg->choice.setup->ext1)
6022                {
6023                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6024                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6025                   free(puschCfg->choice.setup->ext1);
6026                }
6027                free(puschCfg->choice.setup);
6028             }
6029             free(ulCfg->pusch_ServingCellConfig);
6030          }
6031          free(ulCfg->firstActiveUplinkBWP_Id);
6032       }
6033       freeAperDecodeInitialUlBWPConfig(ulBwp);
6034       free(ulCfg->initialUplinkBWP);
6035    }
6036 }
6037
6038 /*******************************************************************
6039  *
6040  * @brief Function to free DuUeCfg
6041  *
6042  * @details
6043  *
6044  *    Function : freeDuUeCfg
6045  *
6046  *    Functionality: Function to free DuUeCfg
6047  *
6048  * @params[in] DuUeCfg *ueCfg
6049  * @return void
6050  *
6051  * ****************************************************************/
6052 void freeDuUeCfg(DuUeCfg *ueCfg)
6053 {
6054    uint8_t lcIdx = 0;
6055    uint8_t arrIdx = 0;
6056    SpCellConfig_t *spCellCfg = NULLP;
6057    ServingCellConfig_t *srvCellCfg = NULLP;
6058    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6059    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6060    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6061    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6062    struct RLC_Config *rlcConfig = NULLP;
6063    struct LogicalChannelConfig *macLcConfig = NULLP;
6064    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6065    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6066    struct TAG_Config *tagConfig = NULLP;
6067    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6068    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6069    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6070    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6071
6072    if(ueCfg->ueNrCapability)
6073    {
6074       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6075       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6076       ueCfg->ueNrCapability = NULLP;
6077    }
6078
6079    if(ueCfg->cellGrpCfg)
6080    {
6081
6082       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6083       if(rlcBearerList)
6084       {
6085          if(rlcBearerList->list.array)
6086          {
6087             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6088             {
6089                if(rlcBearerList->list.array[arrIdx])
6090                {
6091                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6092                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6093
6094                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6095                   {
6096                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6097                   }
6098                   if(rlcConfig)
6099                   {
6100                      if(rlcConfig->choice.am)
6101                      {
6102                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6103                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6104                         free(rlcConfig->choice.am);
6105                      }
6106                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6107                   }
6108                   if(macLcConfig)
6109                   {
6110                      if(macLcConfig->ul_SpecificParameters)
6111                      {
6112                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6113                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6114                         free(macLcConfig->ul_SpecificParameters);
6115                      }
6116                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6117                   }
6118                   free(rlcBearerList->list.array[arrIdx]);
6119                }
6120             }
6121             free(rlcBearerList->list.array);
6122          }
6123          free(cellGrpCfg->rlc_BearerToAddModList);
6124       }
6125
6126       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6127       if(macCellGrpCfg)
6128       {
6129          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6130          if(schedulingRequestConfig)
6131          {
6132             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6133             if(schReqList)
6134             {
6135                if(schReqList->list.array)
6136                {
6137                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6138                   {
6139                      if(schReqList->list.array[arrIdx])
6140                      {
6141                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6142                         free(schReqList->list.array[arrIdx]);
6143                      }
6144                   }
6145                   free(schReqList->list.array);
6146                }
6147                free(schedulingRequestConfig->schedulingRequestToAddModList);
6148             }
6149             free(macCellGrpCfg->schedulingRequestConfig);
6150          }
6151          if(macCellGrpCfg->bsr_Config)
6152          {
6153             free(macCellGrpCfg->bsr_Config);
6154          }
6155          tagConfig = macCellGrpCfg->tag_Config;
6156          if(tagConfig)
6157          {
6158             tagList = tagConfig->tag_ToAddModList;
6159             if(tagList)
6160             {
6161                if(tagList->list.array)
6162                {
6163                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6164                   {
6165                      free(tagList->list.array[arrIdx]);
6166                   }
6167                   free(tagList->list.array);
6168                }
6169                free(tagConfig->tag_ToAddModList);
6170             }
6171             free(tagConfig);
6172          }
6173
6174          phrConfig = macCellGrpCfg->phr_Config;
6175          if(phrConfig)
6176          {
6177             free(phrConfig->choice.setup);
6178             free(phrConfig);
6179          }
6180
6181          free(macCellGrpCfg);
6182       }
6183
6184       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6185       if(phyCellGrpCfg)
6186       {
6187          free(phyCellGrpCfg->p_NR_FR1);
6188          free(phyCellGrpCfg);
6189       }
6190
6191       spCellCfg = cellGrpCfg->spCellConfig;
6192       if(spCellCfg)
6193       {
6194          if(spCellCfg->servCellIndex)
6195          {
6196             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6197             {
6198                if(spCellCfg->spCellConfigDedicated)
6199                {
6200                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6201                   if(srvCellCfg->initialDownlinkBWP)
6202                   {
6203                      dlBwp = srvCellCfg->initialDownlinkBWP;
6204                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6205                      {
6206                         if(srvCellCfg->defaultDownlinkBWP_Id)
6207                         {
6208                            if(srvCellCfg->uplinkConfig)
6209                            {
6210
6211                               if(srvCellCfg->pdsch_ServingCellConfig)
6212                               {
6213                                  pdschCfg=
6214                                     srvCellCfg->pdsch_ServingCellConfig;
6215                                  if(pdschCfg->choice.setup)
6216                                  {
6217
6218                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
6219                                     free(pdschCfg->choice.setup);
6220                                  }
6221
6222                                  free(srvCellCfg->pdsch_ServingCellConfig);
6223                               }
6224
6225                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
6226                               free(srvCellCfg->uplinkConfig);
6227                            }
6228                            free(srvCellCfg->defaultDownlinkBWP_Id);
6229                         }
6230
6231                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
6232                      }
6233                      if(dlBwp->pdcch_Config)
6234                      {
6235                         if(dlBwp->pdsch_Config)
6236                         {
6237                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
6238                            free(dlBwp->pdsch_Config);
6239                         }
6240                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
6241                         free(dlBwp->pdcch_Config);
6242                      }
6243                      free(srvCellCfg->initialDownlinkBWP);
6244                   }
6245
6246                   free(spCellCfg->spCellConfigDedicated);
6247                }
6248                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
6249             }
6250             free(spCellCfg->servCellIndex);
6251          }
6252          free(spCellCfg);
6253       }
6254       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
6255       ueCfg->cellGrpCfg = NULLP;
6256    }
6257    if(ueCfg->ambrCfg)
6258    {
6259       memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
6260       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
6261    }
6262    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
6263    {
6264       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
6265    }
6266    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
6267    {
6268       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
6269    }
6270 }
6271
6272 /*******************************************************************
6273  *
6274  * @brief Function to free UecontextSetupDb
6275  *
6276  * @details
6277  *
6278  *    Function : freeF1UeDb
6279  *
6280  *    Functionality: Function to free UecontextSetupDb
6281  *
6282  * @params[in] UecontextSetupDb *
6283  * @return void
6284  *
6285  * ****************************************************************/
6286
6287 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
6288 {
6289
6290    if(f1UeDb->dlRrcMsg)
6291    {
6292       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
6293       {
6294          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
6295             f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
6296       }
6297       memset(f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
6298    }
6299    freeDuUeCfg(&f1UeDb->duUeCfg);
6300    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
6301    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
6302 }
6303
6304 /*******************************************************************
6305  *
6306  * @brief Function to build Am cfg Info
6307  *
6308  * @details
6309  *
6310  *    Function : extractRlcAmCfg
6311  *
6312  *    Functionality: Function to build Am cfg Info
6313  *
6314  * @params[in] AmBearerCfg *
6315  *             void *
6316  *
6317  * @return ROK/RFAILED
6318  *
6319  * ****************************************************************/
6320
6321 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
6322 {
6323    if(rlcAmCfg)
6324    {
6325       /* UL AM */
6326       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
6327       {
6328          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
6329          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
6330          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
6331       }
6332
6333       /* DL AM */
6334       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
6335       {
6336          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
6337          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
6338          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
6339          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
6340          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
6341       }
6342    }
6343 }
6344
6345 /*******************************************************************
6346  *
6347  * @brief Function to build Um Bi Info
6348  *
6349  * @details
6350  *
6351  *    Function : extractRlcUmBiCfg
6352  *
6353  *    Functionality: Function to build Um Bi Info
6354  *
6355  * @params[in] UmBiDirBearerCfg *
6356  *             void *
6357  *
6358  * @return ROK/RFAILED
6359  *
6360  * ****************************************************************/
6361
6362 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
6363 {
6364    if(rlcBiCfg)
6365    {
6366       /* UL UM BI DIR Cfg */
6367       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
6368       {
6369          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
6370          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
6371       }
6372
6373       /* DL UM BI DIR Cfg */
6374       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
6375          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
6376    }
6377 }
6378
6379 /*******************************************************************
6380  *
6381  * @brief Function to build Um Ul Info
6382  *
6383  * @details
6384  *
6385  *    Function : extractRlcUmUlCfg
6386  *
6387  *    Functionality: Function to build Um Ul Info
6388  *
6389  * @params[in] UmUniDirUlBearerCfg *
6390  *             void *
6391  *
6392  * @return ROK/RFAILED
6393  *
6394  * ****************************************************************/
6395
6396 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
6397 {
6398    if(umUlCfg)
6399    {
6400       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
6401       {
6402          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
6403          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
6404       }
6405    }
6406 }
6407
6408 /*******************************************************************
6409  *
6410  * @brief Function to build Um Uni Dl Info
6411  *
6412  * @details
6413  *
6414  *    Function : extractRlcUmDlCfg
6415  *
6416  *    Functionality: Function to build Um Uni Dl Info
6417  *
6418  * @params[in] UmUniDirDlBearerCfg *
6419  *             void *
6420  *
6421  * @return ROK/RFAILED
6422  *
6423  * ****************************************************************/
6424 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
6425 {
6426    if(umDlCfg)
6427    {
6428       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
6429          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
6430    }
6431 }
6432
6433 /*******************************************************************
6434  *
6435  * @brief Function to extractRlcModeCfg
6436  *
6437  * @details
6438  *
6439  *    Function : extractRlcModeCfg
6440  *
6441  *    Functionality: Function to extractRlcModeCfg
6442  *
6443  * @params[in] RLC_Config_t *
6444  *             RlcBearerCfg *
6445  *             void  *
6446  * @return ROK/RFAILED
6447  *
6448  * ****************************************************************/
6449 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
6450 {
6451    if(lcCfg)
6452    {
6453       switch(rlcMode)
6454       {
6455          case RLC_AM :
6456             {
6457                if(lcCfg->choice.am)
6458                {
6459                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
6460                   if(rlcDbCfg->u.amCfg)
6461                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
6462                }
6463                break;
6464             }
6465          case RLC_UM_BI_DIRECTIONAL :
6466             {
6467                if(lcCfg->choice.um_Bi_Directional)
6468                {
6469                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6470                   if(rlcDbCfg->u.umBiDirCfg)
6471                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
6472                }
6473                break;
6474             }
6475          case RLC_UM_UNI_DIRECTIONAL_UL :
6476             {
6477                if(lcCfg->choice.um_Uni_Directional_DL)
6478                {
6479                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6480                   if(rlcDbCfg->u.umUniDirUlCfg)
6481                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
6482                }
6483                break;
6484             }
6485          case RLC_UM_UNI_DIRECTIONAL_DL :
6486             {
6487                if(lcCfg->choice.um_Uni_Directional_UL)
6488                {
6489                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6490                   if(rlcDbCfg->u.umUniDirDlCfg)
6491                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
6492                }
6493                break;
6494             }
6495          default:
6496             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
6497             break;
6498       }
6499    }
6500 }
6501
6502 /*******************************************************************
6503  *
6504  * @brief Function to extract extractUlLcCfg
6505  *
6506  * @details
6507  *
6508  *    Function : extractUlLcCfg
6509  *
6510  *    Functionality: Function to extract extractUlLcCfg
6511  *
6512  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
6513  * @return void
6514  *
6515  * ****************************************************************/
6516
6517 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
6518 {
6519    if(ulLcCfg)
6520    {
6521       if(ulLcCfg->ul_SpecificParameters)
6522       {
6523          f1UlLcCfg->priority = \
6524             ulLcCfg->ul_SpecificParameters->priority;
6525       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
6526       {
6527          f1UlLcCfg->lcGroup = \
6528            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
6529       }
6530       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
6531       {
6532          f1UlLcCfg->schReqId = \
6533            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
6534       }
6535       f1UlLcCfg->pbr = \
6536          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
6537       f1UlLcCfg->bsd = \
6538          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
6539       }
6540    }
6541 }
6542
6543 /*******************************************************************
6544  *
6545  * @brief Function to procRlcLcCfg
6546  *
6547  * @details
6548  *
6549  *    Function : procRlcLcCfg
6550  *
6551  *    Functionality: Function to procRlcLcCfg
6552  *
6553  * @params[in] rbId, lcId, rbType, rlcMod
6554  *             RLC_Config_t *, RlcBearerCfg * ,
6555  * @return void
6556  *
6557  * ****************************************************************/
6558
6559 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
6560    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
6561 {
6562
6563    lcCfg->rbId   = rbId;
6564    lcCfg->configType = configType;
6565
6566    if(rbType == RB_TYPE_SRB)
6567    {
6568       lcCfg->rbType = RB_TYPE_SRB;
6569       lcCfg->lcId   = rbId;
6570       lcCfg->lcType = LCH_DCCH;
6571       lcCfg->rlcMode = RLC_AM;
6572    }
6573    else if(rbType == RB_TYPE_DRB)
6574    {
6575       lcCfg->rbType = RB_TYPE_DRB;
6576       lcCfg->lcId   = lcId;
6577       lcCfg->lcType = LCH_DTCH;
6578       lcCfg->rlcMode = rlcMode;
6579    }
6580    if(f1RlcCfg) /* rlc mode config recived */
6581    {
6582       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
6583    }
6584 }
6585
6586
6587
6588 /*******************************************************************
6589  *
6590  * @brief Fills DrbQos Info received by CU
6591  *
6592  * @details
6593  *
6594  *    Function : extractQosInfo
6595  *
6596  *    Functionality: Fills DrbQos Info received  by CU
6597  *
6598  * @params[in] DrbQosInfo *qosToAdd,
6599  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
6600  * @return void
6601  *
6602  * ****************************************************************/
6603
6604 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
6605 {
6606    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
6607    qosToAdd->u.nonDyn5Qi.fiveQi     =\
6608          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
6609    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
6610    {
6611       qosToAdd->u.nonDyn5Qi.avgWindow = \
6612         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
6613    }
6614    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
6615       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
6616    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
6617    {
6618       qosToAdd->u.nonDyn5Qi.priorLevel = \
6619          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
6620    }
6621    qosToAdd->ngRanRetPri.priorityLevel = \
6622       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
6623    qosToAdd->ngRanRetPri.preEmptionCap = \
6624       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
6625    qosToAdd->ngRanRetPri.preEmptionVul = \
6626       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
6627    if(qosFlowCfg->gBR_QoS_Flow_Information)
6628    {
6629       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
6630          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
6631          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
6632       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
6633          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
6634          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
6635       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
6636          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
6637          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
6638       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
6639          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
6640          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
6641    }
6642    qosToAdd->pduSessionId = 0;
6643    qosToAdd->ulPduSessAggMaxBitRate = 0;
6644 }
6645
6646 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, LcCfg *macLcToAdd)
6647 {
6648    DRB_Information_t *drbInfo = NULLP;
6649
6650    if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
6651    {
6652       if(drbItem->qoSInformation.choice.choice_extension->value.present ==
6653             QoSInformation_ExtIEs__value_PR_DRB_Information)
6654       {
6655          drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
6656
6657          if(!macLcToAdd->drbQos)
6658          {
6659             DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
6660             if(macLcToAdd->drbQos == NULLP)
6661             {
6662                DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
6663                return RFAILED;
6664             }
6665
6666          }
6667          if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
6668          {
6669             extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
6670             macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
6671          }
6672          if(!macLcToAdd->snssai)
6673          {
6674             DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
6675             if(macLcToAdd->snssai == NULLP)
6676             {
6677                DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
6678                return RFAILED;
6679             }
6680          }
6681          memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
6682                drbInfo->sNSSAI.sST.size);
6683          if(drbInfo->sNSSAI.sD)
6684          {
6685             memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
6686                   drbInfo->sNSSAI.sD->size);
6687          }
6688       }/*End of DRB Info*/
6689    }
6690    return ROK;
6691 }
6692
6693 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg)
6694 {
6695    uint8_t ret = ROK;
6696
6697    if(drbCfg)
6698    {
6699       ret = extractDrbCfg(drbCfg, lcCfg);
6700       if(ret == RFAILED)
6701       {
6702          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
6703          return ret;
6704       }
6705    }
6706    else
6707    {
6708       lcCfg->drbQos = NULLP;
6709       lcCfg->snssai = NULLP;
6710       if(lcCfg->lcId == SRB2_LCID)
6711          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
6712       else
6713          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
6714    }
6715    if(ulLcCfg)
6716    {
6717       lcCfg->ulLcCfgPres = true;
6718       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
6719    }
6720    else
6721       lcCfg->ulLcCfgPres = false;
6722    return ret;
6723 }
6724
6725 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
6726    DRBs_ToBeSetup_Item_t *drbItem, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg)
6727 {
6728    uint8_t ret = ROK;
6729
6730    lcCfg->lcId = lcId;
6731    lcCfg->configType = configType;
6732    if(rbType == RB_TYPE_SRB)
6733    {
6734       ret = extractMacRbCfg(lcId, NULL, ulLcCfg, lcCfg);
6735    }
6736    else if(rbType == RB_TYPE_DRB)
6737    {
6738       ret = extractMacRbCfg(lcId, drbItem, ulLcCfg, lcCfg);
6739    }
6740    return ret;
6741 }
6742
6743 /*******************************************************************
6744  *
6745  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
6746  *
6747  * @details
6748  *
6749  *    Function : extractRlcCfgToAddMod
6750  *
6751  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
6752  *
6753  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
6754  *             DuUeCfg Pointer
6755  * @return ROK/RFAILED
6756  *
6757  * ****************************************************************/
6758
6759 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, \
6760    DuUeCfg *ueCfgDb)
6761 {
6762   uint8_t ret, idx, rbId, lcId, rlcMode, rbType;
6763   RLC_Config_t *f1RlcCfg = NULLP;
6764   LogicalChannelConfig_t *macUlLcCfg = NULLP;
6765
6766   for(idx = 0; idx < lcCfg->list.count; idx++)
6767   {
6768      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
6769      if(lcCfg->list.array[idx]->servedRadioBearer)
6770      {
6771         /* RadioBearer for SRB/DRB */
6772         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
6773         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
6774         {
6775            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
6776            rbType = RB_TYPE_SRB;
6777         }
6778         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
6779         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
6780         {
6781            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
6782            rbType = RB_TYPE_DRB;
6783         }
6784         else
6785         {
6786            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
6787            return RFAILED;
6788         }
6789         /* MAC UL LC Config */
6790         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
6791         {
6792            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
6793         }
6794      }
6795      else
6796      {
6797         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
6798         return RFAILED;
6799      }
6800      /* RLC Mode Config */
6801      if(lcCfg->list.array[idx]->rlc_Config)
6802      {
6803         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
6804         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
6805      }
6806
6807      /* Filling RLC/MAC Config*/
6808      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
6809      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
6810      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
6811      ret = procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx]);
6812      if(ret == RFAILED)
6813      {
6814         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
6815         return ret;
6816      }
6817      (ueCfgDb->numRlcLcs)++;
6818      (ueCfgDb->numMacLcs)++;
6819   }
6820   //TODO: To send the failure cause in UeContextSetupRsp
6821   return ret;
6822 }
6823
6824 /*******************************************************************
6825  *
6826  * @brief DeAlloc pdsch serv cell config info
6827  *
6828  * @details
6829  *
6830  *    Function : freeMacPdschServCellInfo
6831  *
6832  *    Functionality: DeAlloc pdsch serv cell config info
6833  *
6834  * @params[in] PdschServCellCfg pointer
6835  * @return void
6836  *
6837  * ****************************************************************/
6838
6839 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
6840 {
6841    if(pdsch->xOverhead)
6842    {
6843       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(uint8_t));
6844    }
6845    if(pdsch->codeBlkGrpFlushInd)
6846    {
6847       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
6848    }
6849    if(pdsch->maxCodeBlkGrpPerTb)
6850    {
6851       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(uint8_t));
6852    }
6853    if(pdsch->maxMimoLayers)
6854    {
6855       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
6856    }
6857 }
6858
6859 /*******************************************************************
6860  *
6861  * @brief Free Serving cell Info
6862  *
6863  * @details
6864  *
6865  *    Function : freeMacServingCellInfo
6866  *
6867  *    Functionality: Free Serving cell Info
6868  *
6869  * @params[in] ServCellCfgInfo *srvCellCfg
6870  * @return void
6871  *
6872  * ****************************************************************/
6873 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
6874 {
6875    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
6876    if(srvCellCfg->bwpInactivityTmr)
6877    {
6878       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
6879    }
6880 }
6881
6882 /*******************************************************************
6883  *
6884  * @brief Free cell Grp Cfg Info
6885  *
6886  * @details
6887  *
6888  *    Function : freeUeReCfgCellGrpInfo
6889  *
6890  *    Functionality: Free cell Grp Cfg Info
6891  *
6892  * @params[in] MacUeCfg*  duUeCfg
6893  * @return void
6894  *
6895  * ****************************************************************/
6896
6897 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
6898 {
6899    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
6900 }
6901
6902 /*******************************************************************
6903  *
6904  * @brief Fills Reconfig SchReqReConfig
6905  *
6906  * @details
6907  *
6908  *    Function : extractSchReqReConfig
6909  *
6910  *    Functionality: Fills Reconfig SchReqReConfig
6911  *
6912  * @params[in] SchedulingRequestConfig_t *cuSchedReq
6913  *             SchedReqCfg*  macSchedReq
6914  * @return void
6915  *
6916  * ****************************************************************/
6917 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
6918 {
6919    uint8_t schReqIdx = 0;
6920    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
6921    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
6922
6923    if(cuSchedReq->schedulingRequestToAddModList)
6924    {
6925       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
6926       if(schReqListToAdd->list.count)
6927       {
6928          macSchedReq->addModListCount = schReqListToAdd->list.count;
6929          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
6930          {
6931             macSchedReq->addModList[schReqIdx].schedReqId = \
6932                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
6933             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
6934                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
6935             macSchedReq->addModList[schReqIdx].srTransMax    =\
6936                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
6937          }
6938       }
6939    }
6940    /* Scheduling Req To release */
6941    if(cuSchedReq->schedulingRequestToReleaseList)
6942    {
6943       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
6944       if(schReqListToRel->list.count)
6945       {
6946          macSchedReq->relListCount = schReqListToRel->list.count;
6947          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
6948          {
6949             macSchedReq->relList[schReqIdx] = \
6950                *schReqListToRel->list.array[schReqIdx];
6951          }
6952       }
6953    }
6954 }
6955
6956 /*******************************************************************
6957  *
6958  * @brief Fills TagReconfig
6959  *
6960  * @details
6961  *
6962  *    Function : extractTagReconfig
6963  *
6964  *    Functionality: Fills extractTagReconfig
6965  *
6966  * @params[in] TAG_Config_t *cuTagCfg
6967  *             TagCfg *macTagCfg
6968  * @return void
6969  *
6970  * ****************************************************************/
6971
6972 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
6973 {
6974   uint8_t tagIdx = 0;
6975   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
6976   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
6977
6978   /* Tag config to AddMod */
6979   if(cuTagCfg->tag_ToAddModList)
6980   {
6981      tagListToAddMod = cuTagCfg->tag_ToAddModList;
6982      if(tagListToAddMod->list.count)
6983      {
6984         macTagCfg->addModListCount = tagListToAddMod->list.count;
6985         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
6986         {
6987            macTagCfg->addModList[tagIdx].tagId =\
6988               tagListToAddMod->list.array[tagIdx]->tag_Id;
6989            macTagCfg->addModList[tagIdx].timeAlignTimer = \
6990
6991               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
6992         }
6993      }
6994   }
6995   /* Tag config to release */
6996   if(cuTagCfg->tag_ToReleaseList)
6997   {
6998      tagListToRel = cuTagCfg->tag_ToReleaseList;
6999      if(tagListToRel->list.count)
7000      {
7001         macTagCfg->relListCount = tagListToRel->list.count;
7002         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7003         {
7004            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7005         }
7006      }
7007   }
7008 }
7009
7010 /*******************************************************************
7011  *
7012  * @brief Fills PdcchCfg received by CU
7013  *
7014  * @details
7015  *
7016  *    Function : extractPdcchCfg
7017  *
7018  *    Functionality: Fills PdcchCfg received  by CU
7019  *
7020  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7021  *             PdcchConfig *duPdcchCfg
7022  * @return void
7023  *
7024  * ****************************************************************/
7025
7026 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7027 {
7028    uint8_t cRsetIdx = 0;
7029    uint8_t srchSpcIdx = 0;
7030
7031    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7032    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
7033    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
7034    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
7035
7036
7037    /* Control Resource Set To Add/Mod List */
7038    if(cuPdcchCfg->controlResourceSetToAddModList)
7039    {
7040       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
7041       if(cRsetToAddModList->list.count)
7042       {
7043          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
7044          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
7045          {
7046             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
7047               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
7048             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
7049                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
7050             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
7051               cRsetToAddModList->list.array[cRsetIdx]->duration;
7052
7053             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
7054               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
7055             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
7056             {
7057                //TODO: handle the case for Interleaved
7058             }
7059             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
7060               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
7061             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
7062             {
7063                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
7064                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
7065             }
7066          }
7067       }
7068
7069    }
7070    /* Control Resource Set To Release List */
7071    if(cuPdcchCfg->controlResourceSetToReleaseList)
7072    {
7073       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
7074       if(cRsetToRelList->list.count)
7075       {
7076          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
7077          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
7078          {
7079             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
7080          }
7081       }
7082    }
7083
7084    /* Search space To Add/Mod List */
7085    if(cuPdcchCfg->searchSpacesToAddModList)
7086    {
7087       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
7088       if(srchSpcToAddModList->list.count)
7089       {
7090          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
7091          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
7092          {
7093             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
7094                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
7095             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
7096                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
7097             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
7098             {
7099                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
7100                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
7101             }
7102             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
7103             {
7104                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
7105                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
7106             }
7107             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
7108             {
7109               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
7110                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
7111               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
7112                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
7113               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
7114                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
7115
7116               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
7117                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
7118
7119               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
7120                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
7121             }
7122             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
7123             {
7124                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
7125                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
7126                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
7127                {
7128                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
7129                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
7130                }
7131
7132             }
7133          }
7134       }
7135    }
7136    /* Search space To Rel List */
7137    if(cuPdcchCfg->searchSpacesToReleaseList)
7138    {
7139       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
7140       if(srchSpcToRelList->list.count)
7141       {
7142          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
7143          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
7144          {
7145             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
7146                *(srchSpcToRelList->list.array[srchSpcIdx]);
7147          }
7148       }
7149    }
7150 }
7151
7152 /*******************************************************************
7153  *
7154  * @brief Fills PdschCfg received by CU
7155  *
7156  * @details
7157  *
7158  *    Function : extractPdschCfg
7159  *
7160  *    Functionality: Fills PdschCfg received  by CU
7161  *
7162  * @params[in] PDSCH_Config_t *cuPdschCfg,
7163  *             PdschConfig *macPdschCfg
7164  * @return void
7165  *
7166  * ****************************************************************/
7167
7168 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
7169 {
7170    uint8_t timeDomIdx;
7171    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
7172
7173    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7174    {
7175       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
7176          PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
7177       {
7178          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
7179          {
7180             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
7181                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
7182          }
7183       }
7184    }
7185    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
7186    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
7187    {
7188       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
7189       if(timeDomAlloc->present ==\
7190          PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
7191       {
7192          if(timeDomAlloc->choice.setup)
7193          {
7194             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
7195             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
7196             {
7197                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
7198                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
7199                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
7200                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
7201             }
7202          }
7203       }
7204    }
7205    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
7206    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
7207       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
7208    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
7209    {
7210       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7211       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
7212       {
7213          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
7214          {
7215             macPdschCfg->bundlingInfo.StaticBundling.size = \
7216                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
7217          }
7218       }
7219    }
7220    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
7221    {
7222       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7223    }
7224
7225 }
7226
7227 /*******************************************************************
7228  *
7229  * @brief Fills PdschServingCellCfg received by CU
7230  *
7231  * @details
7232  *
7233  *    Function : extractPdschServingCellCfg
7234  *
7235  *    Functionality: Fills PdschCfg received  by CU
7236  *
7237  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
7238  *             PdschServCellCfg *macUePdschSrvCellCfg
7239  * @return ROK/RFAILED
7240  *
7241  * ****************************************************************/
7242
7243 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
7244 {
7245    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
7246    {
7247       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
7248       {
7249          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7250          {
7251             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7252                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7253          }
7254          else
7255          {
7256             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7257             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7258             {
7259                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7260                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7261             }
7262             else
7263             {
7264                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
7265                return RFAILED;
7266             }
7267          }
7268          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7269          {
7270             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7271                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7272          }
7273          else
7274          {
7275             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(bool));
7276             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7277             {
7278                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7279                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7280             }
7281             else
7282             {
7283                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
7284                return RFAILED;
7285             }
7286          }
7287       }
7288    }
7289    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
7290    {
7291       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
7292    }
7293    if(cuPdschSrvCellCfg->ext1)
7294    {
7295       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
7296       {
7297         if(macUePdschSrvCellCfg->maxMimoLayers)
7298         {
7299            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7300         }
7301         else
7302         {
7303            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
7304            if(macUePdschSrvCellCfg->maxMimoLayers)
7305            {
7306               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7307            }
7308            else
7309            {
7310               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
7311               return RFAILED;
7312            }
7313         }
7314       }
7315    }
7316    if(cuPdschSrvCellCfg->xOverhead)
7317    {
7318       if(macUePdschSrvCellCfg->xOverhead)
7319       {
7320          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7321       }
7322       else
7323       {
7324          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(uint8_t));
7325          if(macUePdschSrvCellCfg->xOverhead)
7326          {
7327             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7328          }
7329          else
7330          {
7331             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
7332             return RFAILED;
7333          }
7334       }
7335    }
7336    return ROK;
7337 }
7338
7339 /*******************************************************************
7340  *
7341  * @brief Fills PuschCfg received by CU
7342  *
7343  * @details
7344  *
7345  *    Function : extractPuschCfg
7346  *
7347  *    Functionality: Fills PuschCfg received  by CU
7348  *
7349  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
7350  *             PuschCfg *macPuschCfg
7351  * @return void
7352  *
7353  * ****************************************************************/
7354
7355 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
7356 {
7357    uint8_t timeDomIdx = 0;
7358    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
7359    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
7360
7361    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
7362    {
7363       if(cuPuschCfg->choice.setup)
7364       {
7365          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
7366          {
7367              macPuschCfg->dataScramblingId = \
7368                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
7369          }
7370          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
7371          {
7372             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
7373             {
7374                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
7375                {
7376                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
7377                   if(dmrsUlCfg->dmrs_AdditionalPosition)
7378                   {
7379                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
7380                         *(dmrsUlCfg->dmrs_AdditionalPosition);
7381                   }
7382                   if(dmrsUlCfg->transformPrecodingDisabled)
7383                   {
7384                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
7385                      {
7386                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
7387                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
7388                      }
7389                   }
7390                }
7391             }
7392          }
7393          /*Res Alloc Type for UL */
7394          if(cuPuschCfg->choice.setup->resourceAllocation)
7395          {
7396             macPuschCfg->resourceAllocType = \
7397                cuPuschCfg->choice.setup->resourceAllocation;
7398          }
7399          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
7400          {
7401             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
7402             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
7403             {
7404                if(timeDomAllocList->choice.setup)
7405                {
7406                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
7407                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
7408                   {
7409                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
7410                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
7411                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
7412                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
7413                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
7414                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
7415                   }
7416                }
7417             }
7418          }
7419          if(cuPuschCfg->choice.setup->transformPrecoder)
7420             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
7421       }
7422    }
7423 }
7424
7425 /*******************************************************************
7426  *
7427  * @brief Function to fill pucch Power Control
7428  *
7429  * @details
7430  *
7431  *    Function : extractPucchPowerControl
7432  *
7433  *    Functionality: Function to fill pucch Power Control
7434  *
7435  * @params[in] PucchPowerControl *pwrCtrl,
7436  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
7437  * @return void
7438  *
7439  * ****************************************************************/
7440
7441 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
7442 {
7443    uint8_t arrIdx;
7444
7445    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
7446       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
7447    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
7448       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
7449    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
7450       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
7451    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
7452       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
7453    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
7454       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
7455    if(cuPwrCtrlCfg->p0_Set)
7456    {
7457       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
7458       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
7459       {
7460          pwrCtrl->p0Set[arrIdx].p0PucchId =\
7461             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
7462          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
7463             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
7464       }
7465    }
7466    if(cuPwrCtrlCfg->pathlossReferenceRSs)
7467    {
7468       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
7469       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
7470       {
7471          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
7472             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
7473       }
7474    }
7475 }
7476
7477  /*******************************************************************
7478  *
7479  * @brief Function to extractResrcSetToAddModList sent by CU
7480  *
7481  * @details
7482  *
7483  *    Function : extractResrcSetToAddModList
7484  *
7485  *    Functionality: Fucntion to extractResrcSetToAddModList
7486  *
7487  * @params[in] PucchResrcSetCfg pointer,
7488  *             struct PUCCH_Config__resourceSetToAddModList pointer
7489  * @return void
7490  *
7491  * ****************************************************************/
7492
7493 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
7494 {
7495    uint8_t arrIdx, rsrcListIdx;
7496
7497    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
7498    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
7499    {
7500       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
7501          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
7502       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
7503          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
7504       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
7505       {
7506          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
7507             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
7508       }
7509       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
7510          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
7511    }
7512 }/* End of extractResrcSetToAddModList */
7513
7514 /*******************************************************************
7515  *
7516  * @brief Fills extractResrcToAddModList sent by CU
7517  *
7518  * @details
7519  *
7520  *    Function : extractResrcToAddModList
7521  *
7522  *    Functionality: Fills extractResrcToAddModList
7523  *
7524  * @params[in] PucchResrcCfg pointer,
7525  *             struct PUCCH_Config__resourceToAddModList pointer
7526  * @return ROk/RFAILED
7527  *
7528  * ****************************************************************/
7529
7530 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
7531 {
7532    uint8_t arrIdx;
7533
7534    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
7535    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
7536    {
7537       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
7538         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
7539       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
7540         cuResrcList->list.array[arrIdx]->startingPRB;
7541       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
7542       {
7543          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
7544            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
7545       }
7546       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
7547       {
7548          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
7549            *cuResrcList->list.array[arrIdx]->secondHopPRB;
7550       }
7551       /* PUCCH RSRC FORMAT */
7552       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
7553       {
7554          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
7555          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
7556          {
7557             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
7558             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
7559             {
7560                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
7561                return RFAILED;
7562             }
7563             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
7564                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
7565             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
7566                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
7567             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
7568                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
7569          }
7570       }
7571       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
7572       {
7573          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
7574          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
7575          {
7576             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
7577             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
7578             {
7579                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
7580                return RFAILED;
7581             }
7582             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
7583                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
7584             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
7585                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
7586             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
7587                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
7588             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
7589                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
7590          }
7591       }
7592       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
7593       {
7594          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
7595          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
7596          {
7597             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
7598             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
7599             {
7600                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
7601                return RFAILED;
7602             }
7603             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
7604                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
7605             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
7606                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
7607             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
7608                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
7609          }
7610       }
7611       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
7612       {
7613          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
7614          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
7615          {
7616             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
7617             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
7618             {
7619                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
7620                return RFAILED;
7621             }
7622             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
7623                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
7624             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
7625                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
7626             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
7627                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
7628          }
7629       }
7630       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
7631       {
7632          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
7633          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
7634          {
7635             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
7636             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
7637             {
7638                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
7639                return RFAILED;
7640             }
7641             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
7642                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
7643             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
7644                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
7645             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
7646                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
7647             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
7648                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
7649          }
7650       }
7651    }
7652    return ROK;
7653
7654 }/* End of extractResrcToAddModList */
7655
7656 /*******************************************************************
7657  *
7658  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
7659  *
7660  * @details
7661  *
7662  *    Function : fillPucchSchedReqPeriodAndOffset
7663  *
7664  *    Functionality: To fillPucchSchedReqPeriodAndOffset
7665  *
7666  * @params[in] macPeriodicty,
7667  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
7668  * @return void
7669  *
7670  * ****************************************************************/
7671
7672 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
7673    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
7674 {
7675    macPeriodicty = cuPeriodicty->present;
7676    switch(macPeriodicty)
7677    {
7678       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
7679          {
7680             macOffset     = cuPeriodicty->choice.sym2;
7681             break;
7682          }
7683       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
7684          {
7685             macOffset     = cuPeriodicty->choice.sym6or7;
7686             break;
7687          }
7688       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
7689          {
7690             macOffset     = cuPeriodicty->choice.sl1;
7691             break;
7692          }
7693       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
7694          {
7695             macOffset = cuPeriodicty->choice.sl2;
7696             break;
7697          }
7698       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
7699          {
7700             macOffset = cuPeriodicty->choice.sl4;
7701             break;
7702          }
7703       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
7704          {
7705             macOffset = cuPeriodicty->choice.sl5;
7706             break;
7707          }
7708       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
7709          {
7710             macOffset = cuPeriodicty->choice.sl8;
7711             break;
7712          }
7713       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
7714          {
7715             macOffset = cuPeriodicty->choice.sl10;
7716             break;
7717          }
7718       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
7719          {
7720             macOffset = cuPeriodicty->choice.sl16;
7721             break;
7722          }
7723       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
7724          {
7725             macOffset = cuPeriodicty->choice.sl20;
7726             break;
7727          }
7728       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
7729          {
7730             macOffset = cuPeriodicty->choice.sl40;
7731             break;
7732          }
7733       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
7734          {
7735             macOffset = cuPeriodicty->choice.sl80;
7736             break;
7737          }
7738       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
7739          {
7740             macOffset = cuPeriodicty->choice.sl160;
7741             break;
7742          }
7743       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
7744          {
7745             macOffset = cuPeriodicty->choice.sl320;
7746             break;
7747          }
7748       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
7749          {
7750             macOffset = cuPeriodicty->choice.sl640;
7751             break;
7752          }
7753       default :
7754          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
7755    }
7756 }
7757
7758 /*******************************************************************
7759  *
7760  * @brief Function to extractPucchFormatCfg sent by CU
7761  *
7762  * @details
7763  *
7764  *    Function : extractPucchFormatCfg
7765  *
7766  *    Functionality: Function to extractPucchFormatCfg
7767  *
7768  * @params[in] PucchFormatCfg pointer,
7769  *             PUCCH_FormatConfig_t pointer
7770  * @return void
7771  *
7772  * ****************************************************************/
7773
7774 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
7775  {
7776     if(cuFormatCfg->interslotFrequencyHopping)
7777        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
7778     if(cuFormatCfg->additionalDMRS)
7779        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
7780     if(cuFormatCfg->maxCodeRate)
7781        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
7782     if(cuFormatCfg->nrofSlots)
7783        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
7784     if(cuFormatCfg->pi2BPSK)
7785        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
7786     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
7787        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
7788  }/* End of extractPucchFormatCfg */
7789
7790 /*******************************************************************
7791  *
7792  * @brief Function to extractSchedReqCfgToAddMod sent by CU
7793  *
7794  * @details
7795  *
7796  *    Function : extractSchedReqCfgToAddMod
7797  *
7798  *    Functionality: Function to extractSchedReqCfgToAddMod
7799  *
7800  * @params[in] PucchSchedReqCfg pointer,
7801  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
7802  * @return void
7803  *
7804  * ****************************************************************/
7805
7806 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
7807 {
7808    uint8_t arrIdx;
7809
7810    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
7811    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
7812    {
7813       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
7814          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
7815       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
7816          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
7817       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
7818       {
7819          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
7820             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
7821       }
7822       if(cuSchedReqList->list.array[arrIdx]->resource)
7823       {
7824          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
7825             *cuSchedReqList->list.array[arrIdx]->resource;
7826       }
7827    }
7828
7829 }/* End of extractSchedReqCfgToAddMod */
7830
7831  /*******************************************************************
7832  *
7833  * @brief Fills PucchCfg received by CU
7834  *
7835  * @details
7836  *
7837  *    Function : extractPucchCfg
7838  *
7839  *    Functionality: Fills PucchCfg received  by CU
7840  *
7841  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
7842  *             PucchCfg *macPucchCfg
7843  * @return ROK/RFAILED
7844  *
7845  * ****************************************************************/
7846
7847 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
7848 {
7849    uint8_t arrIdx;
7850
7851    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
7852    {
7853       if(cuPucchCfg->choice.setup)
7854       {
7855          /* Resource Set Cfg */
7856          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
7857          {
7858             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
7859             if(macPucchCfg->resrcSet == NULLP)
7860             {
7861                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
7862                return RFAILED;
7863             }
7864             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
7865             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
7866          }
7867
7868          /* Resource Cfg */
7869          if(cuPucchCfg->choice.setup->resourceToAddModList)
7870          {
7871             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
7872             if(macPucchCfg->resrc == NULLP)
7873             {
7874                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
7875                return RFAILED;
7876             }
7877             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
7878             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
7879          }
7880
7881          /* Format 1 Cfg */
7882          if(cuPucchCfg->choice.setup->format1)
7883          {
7884             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
7885             if(macPucchCfg->format1 == NULLP)
7886             {
7887                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
7888                return RFAILED;
7889             }
7890             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
7891             extractPucchFormatCfg(macPucchCfg->format1,\
7892                cuPucchCfg->choice.setup->format1->choice.setup);
7893          }
7894
7895          /* Format 2 Cfg */
7896          if(cuPucchCfg->choice.setup->format2)
7897          {
7898             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
7899             if(macPucchCfg->format2 == NULLP)
7900             {
7901                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
7902                return RFAILED;
7903             }
7904             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
7905             extractPucchFormatCfg(macPucchCfg->format2,\
7906                cuPucchCfg->choice.setup->format2->choice.setup);
7907          }
7908
7909          /* Format 3 Cfg */
7910          if(cuPucchCfg->choice.setup->format3)
7911          {
7912             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
7913             if(macPucchCfg->format3 == NULLP)
7914             {
7915                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
7916                return RFAILED;
7917             }
7918             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
7919             extractPucchFormatCfg(macPucchCfg->format3,\
7920                cuPucchCfg->choice.setup->format3->choice.setup);
7921          }
7922
7923          /* Format 4 Cfg */
7924          if(cuPucchCfg->choice.setup->format4)
7925          {
7926             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
7927             if(macPucchCfg->format4 == NULLP)
7928             {
7929                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
7930                return RFAILED;
7931             }
7932             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
7933             extractPucchFormatCfg(macPucchCfg->format4,\
7934                cuPucchCfg->choice.setup->format4->choice.setup);
7935          }
7936
7937          /* Sched Req List */
7938          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
7939          {
7940             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
7941             if(macPucchCfg->schedReq == NULLP)
7942             {
7943                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
7944                return RFAILED;
7945             }
7946             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
7947             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
7948             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
7949          }
7950
7951          /*TODO: Add support for  Spatial Info */
7952
7953          /* MultiCsiCfg */
7954          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
7955          {
7956             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
7957             if(macPucchCfg->multiCsiCfg == NULLP)
7958             {
7959                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
7960                return RFAILED;
7961             }
7962             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
7963             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
7964             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
7965             {
7966                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
7967                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
7968             }
7969          }
7970
7971          /* Dl_DataToUL_ACK */
7972          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
7973          {
7974             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7975             if(macPucchCfg->dlDataToUlAck == NULLP)
7976             {
7977                DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
7978                return RFAILED;
7979             }
7980             memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
7981             macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
7982             for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
7983             {
7984                macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
7985                   *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
7986             }
7987          }
7988
7989          /* Power Control */
7990          if(cuPucchCfg->choice.setup->pucch_PowerControl)
7991          {
7992             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
7993             if(macPucchCfg->powerControl == NULLP)
7994             {
7995                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
7996                return RFAILED;
7997             }
7998             extractPucchPowerControl(macPucchCfg->powerControl,\
7999                cuPucchCfg->choice.setup->pucch_PowerControl);
8000          }
8001       }
8002    }
8003    return ROK;
8004 }
8005
8006 /*******************************************************************
8007  *
8008  * @brief Fills ServingCellReconfig received by CU
8009  *
8010  * @details
8011  *
8012  *    Function : extractSpCellDedicatedCfg
8013  *
8014  *    Functionality: Fills ServingCellReconfig received  by CU
8015  *
8016  * @params[in] ServingCellConfig_t *cuSrvCellCfg
8017  *             ServCellCfgInfo *macSrvCellCfg
8018  * @return ROK/RFAILD
8019  *
8020  * ****************************************************************/
8021 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
8022 {
8023    uint8_t ret = ROK;
8024    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8025    BWP_UplinkDedicated_t   *ulBwp = NULLP;
8026
8027    if(cuSrvCellCfg->initialDownlinkBWP)
8028    {
8029       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
8030       if(dlBwp->pdcch_Config)
8031       {
8032          if(dlBwp->pdcch_Config->choice.setup)
8033          {
8034             macSrvCellCfg->initDlBwp.pdcchPresent = true;
8035             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
8036          }
8037       }
8038       if(dlBwp->pdsch_Config)
8039       {
8040          if(dlBwp->pdsch_Config->choice.setup)
8041          {
8042             macSrvCellCfg->initDlBwp.pdschPresent = true;
8043             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
8044          }
8045       }
8046    }
8047    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
8048       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
8049    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
8050       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
8051    if(cuSrvCellCfg->bwp_InactivityTimer)
8052    {
8053       if(macSrvCellCfg->bwpInactivityTmr)
8054       {
8055          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8056       }
8057       else
8058       {
8059          macSrvCellCfg->bwpInactivityTmr = NULLP;
8060          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8061          if(macSrvCellCfg->bwpInactivityTmr)
8062          {
8063             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8064          }
8065          else
8066          {
8067             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
8068             return RFAILED;
8069          }
8070       }
8071    }
8072    if(cuSrvCellCfg->pdsch_ServingCellConfig)
8073    {
8074       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
8075       {
8076          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
8077          if(ret == RFAILED)
8078          {
8079             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
8080             return RFAILED;
8081          }
8082       }
8083    }
8084    if(cuSrvCellCfg->uplinkConfig)
8085    {
8086      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
8087      {
8088         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
8089         if(ulBwp->pusch_Config)
8090         {
8091            macSrvCellCfg->initUlBwp.puschPresent = true;
8092            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
8093         }
8094         if(ulBwp->pucch_Config)
8095         {
8096            macSrvCellCfg->initUlBwp.pucchPresent = true;
8097            memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
8098            extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
8099         }
8100      }
8101      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
8102         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
8103    }
8104    return ret;
8105 }
8106 /*******************************************************************
8107  *
8108  * @brief Fills Reconfig Cell group Info received by CU
8109  *
8110  * @details
8111  *
8112  *    Function : extractUeReCfgCellInfo
8113  *
8114  *    Functionality: Fills Reconfig Cell group Info received by CU
8115  *
8116  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
8117  *             MacUeCfg*  macUeCfg
8118  * @return ROK/RFAILED
8119  *
8120  * ****************************************************************/
8121 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
8122 {
8123    uint8_t ret = ROK;
8124    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
8125    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8126    SpCellConfig_t            *spcellCfg = NULLP;
8127    ServingCellConfig_t       *servCellCfg = NULLP;
8128
8129    if(cellGrp)
8130    {
8131       /* Fill MacCell Group Reconfig  */
8132       if(cellGrp->mac_CellGroupConfig)
8133       {
8134          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
8135          if(macCellGroup->schedulingRequestConfig)
8136          {
8137             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
8138          }
8139          if(macCellGroup->tag_Config)
8140          {
8141             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
8142          }
8143          if(macCellGroup->bsr_Config)
8144          {
8145             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
8146             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
8147             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
8148             {
8149                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
8150                   *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
8151             }
8152          }
8153          if(macCellGroup->phr_Config)
8154          {
8155             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
8156             {
8157                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
8158                if(macCellGroup->phr_Config->choice.setup)
8159                {
8160                 macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
8161                    macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
8162                 macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
8163                    macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
8164                 macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
8165                    macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
8166                 macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
8167                    macCellGroup->phr_Config->choice.setup->multiplePHR;
8168                 macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
8169                    macCellGroup->phr_Config->choice.setup->dummy;
8170                 macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
8171                    macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
8172                 macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
8173                    macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
8174                }
8175             }
8176          }
8177       }
8178       /* Fill Physical Cell Group Reconfig */
8179       if(cellGrp->physicalCellGroupConfig)
8180       {
8181          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
8182          if(phyCellGrpCfg->p_NR_FR1)
8183          {
8184             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
8185                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
8186          }
8187          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
8188       }
8189       /* Fill SpCell Reconfig */
8190       if(cellGrp->spCellConfig)
8191       {
8192          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
8193          if(spcellCfg->servCellIndex)
8194          {
8195             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
8196          }
8197          /* Fill Serving cell Reconfig info */
8198          if(cellGrp->spCellConfig->spCellConfigDedicated)
8199          {
8200             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
8201             ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
8202             if(ret == RFAILED)
8203             {
8204                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
8205             }
8206          }
8207       }
8208    }
8209    return ret;
8210 }
8211 /*******************************************************************
8212 *
8213 * @brief free the memory allocated by decoder
8214 *
8215 * @details
8216 *
8217 *    Function : freeAperDecodeNrcgi
8218 *
8219 *    Functionality: Free Nrcgi values
8220 *
8221 * @params[in] NRCGI_t *nrcgi
8222 * @return void
8223 *
8224 * ****************************************************************/
8225
8226
8227 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
8228 {
8229     if(nrcgi->pLMN_Identity.buf != NULLP)
8230     {
8231        free(nrcgi->pLMN_Identity.buf);
8232     }
8233     if(nrcgi->nRCellIdentity.buf != NULLP)
8234     {
8235        free(nrcgi->nRCellIdentity.buf);
8236     }
8237 }
8238 /*******************************************************************
8239 *
8240 * @brief free the memory allocated by decoder
8241 *
8242 * @details
8243 *
8244 *    Function : freeAperDecodeCuToDuInfo
8245 *
8246 *    Functionality:  Free Cu To Du Information
8247 *
8248 * @params[in] CUtoDURRCInformation_t *rrcMsg
8249 * @return void
8250 *
8251 * ****************************************************************/
8252
8253
8254 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8255 {
8256    uint8_t ieIdx =0;
8257    uint8_t arrIdx =0;
8258
8259    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8260    {
8261       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8262          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
8263       free(rrcMsg->uE_CapabilityRAT_ContainerList);
8264    }
8265
8266    if(rrcMsg->iE_Extensions)
8267    {
8268       if(rrcMsg->iE_Extensions->list.array)
8269       {
8270          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
8271          {
8272             if(rrcMsg->iE_Extensions->list.array[ieIdx])
8273             {
8274                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
8275                {
8276                   case ProtocolIE_ID_id_CellGroupConfig:
8277                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8278                      {
8279                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
8280                      }
8281                      break;
8282                   default:
8283                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8284                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
8285                      break;
8286                }
8287             }
8288          }
8289          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8290          {
8291             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
8292          }
8293          free(rrcMsg->iE_Extensions->list.array);
8294
8295       }
8296
8297       free(rrcMsg->iE_Extensions);
8298    }
8299 }
8300 /*******************************************************************
8301 *
8302 * @brief free the memory allocated by decoder
8303 *
8304 * @details
8305 *
8306 *    Function : freeAperDecodeSplCellList
8307 *
8308 *    Functionality: Free Spl Cell List
8309                     where memory allocated by aper_decoder
8310 *
8311 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
8312 * @return void
8313 *
8314 * ****************************************************************/
8315
8316
8317 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
8318 {
8319     uint8_t  cellIdx =0;
8320
8321     if(spCellLst->list.array != NULLP)
8322     {
8323        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
8324        {
8325           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
8326           {
8327              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
8328           }
8329           if(spCellLst->list.array[cellIdx]!=NULLP)
8330           {
8331              free(spCellLst->list.array[cellIdx]);
8332           }
8333        }
8334        free(spCellLst->list.array);
8335     }
8336 }
8337 /*******************************************************************
8338 *
8339 * @brief free the memory allocated by decoder
8340 *
8341 * @details
8342 *
8343 *    Function : freeAperDecodeSRBSetup
8344 *
8345 *    Functionality: added free part for the memory allocated by aper_decoder
8346 *
8347 * @params[in] SRBs_ToBeSetup_List_t *srbSet
8348 * @return void
8349 *
8350 ****************************************************************/
8351
8352
8353 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
8354 {
8355     uint8_t srbIdx =0;
8356     if(srbSet->list.array != NULLP)
8357     {
8358        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
8359        {
8360           if(srbSet->list.array[srbIdx]!=NULLP)
8361           {
8362              free(srbSet->list.array[srbIdx]);
8363           }
8364        }
8365        free(srbSet->list.array);
8366     }
8367 }
8368
8369 /*******************************************************************
8370 *
8371 * @brief free the memory allocated by decoder
8372 *
8373 * @details
8374 *
8375 *    Function : freeAperDecodeULTnlInfo
8376 *
8377 *    Functionality: added free part for the memory allocated by aper_decoder
8378 *
8379 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
8380 * @return void
8381 *
8382 * ****************************************************************/
8383
8384
8385 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
8386 {
8387    uint8_t ulIdx=0;
8388    if(ulInfo->list.array != NULLP)
8389    {
8390       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
8391       {
8392          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
8393          {
8394             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
8395             {
8396                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
8397                      transportLayerAddress.buf != NULLP)
8398                {
8399                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
8400                         !=NULLP)
8401                   {
8402                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
8403                   }
8404                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
8405                         transportLayerAddress.buf);
8406                }
8407                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
8408             }
8409          }
8410          if(ulInfo->list.array[ulIdx]!=NULLP)
8411          {
8412             free(ulInfo->list.array[ulIdx]);
8413          }
8414       }
8415       free(ulInfo->list.array);
8416    }
8417 }
8418 /*******************************************************************
8419 *
8420 * @brief free the memory allocated by decoder
8421 *
8422 * @details
8423 *
8424 *    Function : freeAperDecodeDRBSetup
8425 *
8426 *    Functionality: free DRBSetup which is allocated by decoder
8427 *
8428 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
8429 * @return void
8430 *
8431 * ****************************************************************/
8432
8433 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
8434 {
8435    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
8436    uint8_t  flowIdx =0;
8437    uint8_t  drbIdx =0;
8438
8439    if(drbSet->list.array != NULLP)
8440    {
8441       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
8442       {
8443          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
8444          {
8445             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
8446             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
8447             {
8448                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
8449                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
8450                {
8451                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
8452                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
8453                   {
8454                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
8455                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
8456                      {
8457
8458                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
8459                         {
8460
8461                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
8462                            {
8463
8464                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
8465                               buf!=NULLP)
8466                               {
8467
8468                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
8469                                        flows_Mapped_To_DRB_List.list.array != NULLP)
8470                                  {
8471
8472                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8473                                     DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
8474                                     {
8475
8476                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8477                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
8478                                        {
8479                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8480                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8481                                                 qoSFlowLevelQoSParameters.\
8482                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
8483                                           {
8484                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8485                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8486                                                    qoSFlowLevelQoSParameters.\
8487                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
8488                                              {
8489
8490                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8491                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8492                                                       qoSFlowLevelQoSParameters.\
8493                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
8494                                                 {
8495                                                    freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
8496                                                    free(drbSetItem->uLConfiguration);
8497
8498
8499                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8500                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8501                                                          qoSFlowLevelQoSParameters.\
8502                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
8503                                                 }
8504
8505                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8506                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8507                                                       qoSFlowLevelQoSParameters.\
8508                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
8509                                              }
8510
8511                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8512
8513                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8514                                                    qoSFlowLevelQoSParameters.\
8515                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
8516                                           }
8517                                        }
8518                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8519                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
8520                                        {
8521
8522                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8523                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
8524                                        }
8525                                     }
8526
8527                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8528                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
8529                                  }
8530
8531                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8532                                  DRB_Information.sNSSAI.sD->buf);
8533                               }
8534
8535                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
8536                            }
8537
8538                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
8539
8540                         }
8541
8542                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
8543
8544                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
8545                      }
8546
8547                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
8548                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
8549                   }
8550
8551                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
8552                         qoS_Characteristics.choice.non_Dynamic_5QI);
8553                }
8554                free(drbSetItem->qoSInformation.choice.choice_extension);
8555             }
8556          }
8557          if(drbSet->list.array[drbIdx]!=NULLP)
8558          {
8559             free(drbSet->list.array[drbIdx]);
8560          }
8561       }
8562       free(drbSet->list.array);
8563    }
8564 }
8565
8566
8567 /*******************************************************************
8568  *
8569  * @brief builds Mac Cell Cfg
8570  *
8571  * @details
8572  *
8573  *    Function : procUeReCfgCellInfo
8574  *
8575  *    Functionality: builds Mac Cell Cfg
8576  *
8577  * @params[in] MacUeCfg pointer
8578  *             void pointer
8579  *
8580  * @return void
8581  *
8582  * ****************************************************************/
8583 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
8584 {
8585    uint8_t ret = ROK;
8586    CellGroupConfigRrc_t *cellGrp = NULLP;
8587
8588    if(cellInfo)
8589    {
8590       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
8591       ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
8592       if(ret == RFAILED)
8593          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
8594    }
8595    if(ret == RFAILED)
8596    {
8597       freeUeReCfgCellGrpInfo(macUeCfg);
8598    }
8599    return ret;
8600 }
8601
8602 /*******************************************************************
8603  *
8604  * @brief Filling modulation info in mac ue cfg
8605  *
8606  * @details
8607  *
8608  *    Function : duFillModulationDetails
8609  *
8610  *    Functionality: Filling modulation info in mac ue cfg
8611  *
8612  * @params[in] MAC UE Config to be updated
8613  *             Current UE configuration
8614  *             UE NR capability from CU
8615  * @return ROK     - success
8616  *         RFAILED - failure
8617  *
8618  * ****************************************************************/
8619 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
8620 {
8621    UE_NR_Capability_t *ueNrCap;
8622
8623    if(ueCap)
8624       ueNrCap = (UE_NR_Capability_t *)ueCap;
8625
8626    /* Filling DL modulation info */
8627    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
8628          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
8629          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
8630    {
8631       switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
8632       {
8633          case ModulationOrder_qpsk:
8634             {
8635                ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
8636                break;
8637             }
8638          case ModulationOrder_qam16:
8639             {
8640                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
8641                break;
8642             }
8643          case ModulationOrder_qam64:
8644             {
8645                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
8646                ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
8647                ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
8648                break;
8649             }
8650          case ModulationOrder_qam256:
8651             {
8652                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
8653                break;
8654             }
8655          default:
8656             {
8657                DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
8658                memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
8659                break;
8660             }
8661       }
8662    }
8663    else
8664    {
8665       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
8666    }
8667
8668    /* Filling UL modulation info */
8669    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
8670          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
8671          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
8672    {
8673       switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
8674       {
8675          case ModulationOrder_qpsk:
8676             {
8677                ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
8678                break;
8679             }
8680          case ModulationOrder_qam16:
8681             {
8682                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
8683                ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
8684                ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
8685                break;
8686             }
8687          case ModulationOrder_qam64:
8688             {
8689                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
8690                break;
8691             }
8692          case ModulationOrder_qam256:
8693             {
8694                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
8695                break;
8696             }
8697          default:
8698             {
8699                DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
8700                memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
8701                break;
8702             }
8703       }
8704    }
8705    else
8706    {
8707       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
8708    }
8709 }
8710
8711 /*******************************************************************
8712  *
8713  * @brief Function to extract cellGrp Info present in cutoDu cont
8714  *
8715  * @details
8716  *
8717  *    Function : extractCellGrpInfo
8718  *
8719  *    Functionality: Function to extract cellGrp Info present
8720  *                   in cutoDu cont
8721  *
8722  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
8723  *
8724  * @return CellGroupConfigRrc_t *
8725  *
8726  * ****************************************************************/
8727
8728 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
8729    DuUeCfg *ueCfgDb)
8730 {
8731    uint8_t idx2 =0;
8732    uint16_t id =0;
8733    uint16_t recvBufLen =0;
8734    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
8735    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
8736    asn_dec_rval_t rval; /* Decoder return value */
8737    memset(&rval, 0, sizeof(asn_dec_rval_t));
8738
8739    if(protocolIeExtn)
8740    {
8741       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
8742       {
8743          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
8744          id = extIeInfo->id;
8745          switch(id)
8746          {
8747             case ProtocolIE_ID_id_CellGroupConfig:
8748             {
8749                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
8750                /* decoding the CellGroup Buf received */
8751                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
8752                if(cellGrpCfg)
8753                {
8754                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
8755                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
8756                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
8757                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
8758                   {
8759                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
8760                      return NULLP;
8761                   }
8762                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
8763                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
8764                      return NULLP;
8765                }
8766                break;
8767             }
8768             default:
8769                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
8770                break;
8771          }
8772       }
8773    }
8774    return cellGrpCfg;
8775 }
8776
8777 /*******************************************************************
8778  *
8779  * @brief Fills Srb List received by CU
8780  *
8781  * @details
8782  *
8783  *    Function : procSrbListToSetup
8784  *
8785  *    Functionality: Fills Srb List received  by CU
8786  *
8787  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
8788  *             LcCfg pointer
8789  *             RlcBearerCfg pointer
8790  * @return void
8791  *
8792  * ****************************************************************/
8793 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
8794 {
8795    uint8_t ret = ROK;
8796
8797    /* Filling RLC INFO */
8798    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
8799
8800    /* Filling MAC INFO */
8801    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL, NULL, macLcToAdd);
8802    if(ret == RFAILED)
8803    {
8804       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
8805       return ret;
8806    }
8807    return ret;
8808 }
8809
8810
8811
8812 /*******************************************************************
8813  *
8814  * @brief extract Srb List received by CU
8815  *
8816  * @details
8817  *
8818  *    Function : extractSrbListToSetup
8819  *
8820  *    Functionality: extract Srb List received by CU
8821  *                   for both MAC and RLC
8822  *
8823  * @params[in] SRBs_ToBeSetup_Item_t pointer
8824  *             DuUeCfg pointer
8825  * @return ROK/RFAIED
8826  *
8827  * ****************************************************************/
8828
8829 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
8830 {
8831    uint8_t ret, srbIdx;
8832    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
8833
8834    if(srbCfg)
8835    {
8836       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
8837       {
8838          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
8839          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
8840          {
8841             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
8842             ret = RFAILED;
8843             break;
8844          }
8845          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
8846          {
8847             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
8848             ret = RFAILED;
8849             break;
8850          }
8851          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
8852          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
8853          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
8854             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
8855          ueCfgDb->numRlcLcs++;
8856          ueCfgDb->numMacLcs++;
8857          if(ret == RFAILED)
8858          {
8859             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
8860             break;
8861          }
8862       }
8863    }
8864    else
8865       ret = RFAILED;
8866
8867    return ret;
8868 }
8869
8870 /*******************************************************************
8871  *
8872  * @brief Fills Drb List received by CU
8873  *
8874  * @details
8875  *
8876  *    Function : procDrbListToSetup
8877  *
8878  *    Functionality: Fills Drb List received by CU
8879  *                   for both MAC and RLC
8880  *
8881  * @params[in] SRBs_ToBeSetup_Item_t pointer
8882  *             LcCfg pointer,
8883  *             RlcBearerCfg pointer
8884  * @return void
8885  *
8886  * ****************************************************************/
8887
8888 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
8889 {
8890    uint8_t ret = ROK;
8891
8892    /* Filling RLC INFO */
8893    procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
8894
8895    /* Filling MAC INFO */
8896    ret = procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, macLcToAdd);
8897    if(ret == RFAILED)
8898    {
8899       DU_LOG("\nERROR  -->  F1AP : Failed at RLC LC Cfg in extractDrbListToSetup()");
8900       return ret;
8901    }
8902
8903    return ret;
8904 }
8905
8906 /*******************************************************************
8907  *
8908  * @brief extract Drb List received by CU
8909  *
8910  * @details
8911  *
8912  *    Function : extractDrbListToSetup
8913  *
8914  *    Functionality: extract Drb List received by CU
8915  *                   for both MAC and RLC
8916  *
8917  * @params[in] DRBs_ToBeSetup_Item_t pointer
8918  *             DuUeCfg pointer
8919  * @return ROK/RFAIED
8920  *
8921  * ****************************************************************/
8922
8923 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg, DuUeCfg *ueCfgDb)
8924 {
8925    uint8_t ret, drbIdx;
8926    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
8927
8928    ret = ROK;
8929    if(drbCfg)
8930    {
8931       for(drbIdx = 0; drbIdx < drbCfg->list.count; drbIdx++)
8932       {
8933          drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
8934          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
8935          {
8936             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC ");
8937             ret = RFAILED;
8938             break;
8939          }
8940          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
8941          {
8942             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
8943             ret = RFAILED;
8944             break;
8945          }
8946          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
8947          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
8948          ret = procDrbListToSetup(lcId, drbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
8949             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
8950          ueCfgDb->numRlcLcs++;
8951          ueCfgDb->numMacLcs++;
8952          if(ret == RFAILED)
8953          {
8954             DU_LOG("\nERROR  -->  F1AP :  Failed at extractDrbListToSetup()");
8955             break;
8956          }
8957       }
8958    }
8959    else
8960       ret = RFAILED;
8961
8962    return ret;
8963 }
8964
8965 /*******************************************************************
8966  *
8967  * @brief Function to extract Dl RRC Msg received from CU
8968  *
8969  * @details
8970  *
8971  *    Function : extractDlRrcMsg
8972  *
8973  *    Functionality: Function to extract Dl RRC Msg received from CU
8974  *
8975  * @params[in] F1AP message
8976  * @return ROK     - success
8977  *         RFAILED - failure
8978  *
8979  * ****************************************************************/
8980
8981 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
8982    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
8983 {
8984    uint8_t ret = ROK;
8985    dlRrcMsg->rrcMsgSize = rrcContainer->size;
8986    if(dlRrcMsg->rrcMsgSize > 0)
8987    {
8988       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
8989       if(!dlRrcMsg->rrcMsgPdu)
8990       {
8991          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for RRC Msg in procUeCtxtSetupReq");
8992          ret = RFAILED;
8993       }
8994       else
8995       {
8996          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
8997          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
8998          dlRrcMsg->srbId = SRB1_LCID;
8999          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
9000       }
9001    }
9002    return ret;
9003 }
9004
9005 /*******************************************************************
9006  *
9007  * @brief Extract UE capability info
9008  *
9009  * @details
9010  *
9011  *    Function : extractUeCapability
9012  *
9013  *    Functionality: Extract UE capability info and stores in ue Cb
9014  *
9015  * @params[in] Octet string of UE capability RAT container list
9016  * @return ROK     - success
9017  *         RFAILED - failure
9018  *
9019  * ****************************************************************/
9020 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
9021 {
9022    uint8_t  idx;
9023    uint16_t recvBufLen;
9024    asn_dec_rval_t rval;
9025    UE_NR_Capability_t  *ueNrCap = NULLP;
9026    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
9027
9028    /* Decoding UE Capability RAT Container List */
9029    recvBufLen = ueCapablityListBuf->size;
9030    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9031    if(!ueCapRatContList)
9032    {
9033       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9034       return NULLP;
9035    }
9036    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9037    memset(&rval, 0, sizeof(asn_dec_rval_t));
9038    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
9039           ueCapablityListBuf->buf, recvBufLen, 0, 0);
9040    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9041    {
9042       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9043       return NULLP;
9044    }
9045    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
9046
9047    /* Free encoded buffer after decoding */
9048
9049    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
9050    {
9051       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
9052       {
9053          /* Decoding UE NR Capability */
9054           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
9055           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
9056           if(!ueNrCap)
9057           {
9058              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9059              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9060              return NULLP;
9061           }
9062           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
9063           memset(&rval, 0, sizeof(asn_dec_rval_t));
9064           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
9065                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
9066           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9067           {
9068              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9069              return NULLP;
9070           }
9071           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
9072
9073           /* Free encoded buffer after decoding */
9074           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
9075       }
9076       free(ueCapRatContList->list.array[idx]);
9077    }
9078
9079    /* Free Memory*/
9080    free(ueCapRatContList->list.array);
9081    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9082    return ueNrCap;
9083 }
9084
9085 /*******************************************************************
9086 *
9087 * @brief free UE context setup request from CU
9088 *
9089 * @details
9090 *
9091 *    Function : freeAperDecodeF1UeContextSetupReq
9092 *
9093 *    Functionality: freeing part for the memory allocated by aper_decoder
9094 *
9095 * @params[in] F1AP message
9096 * @return ROK     - success
9097 *         RFAILED - failure
9098 *
9099 * ****************************************************************/
9100 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
9101 {
9102    uint8_t ieIdx = 0;
9103
9104    if(ueSetReq->protocolIEs.list.array != NULLP)
9105    {
9106       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
9107       {
9108          if(ueSetReq->protocolIEs.list.array[ieIdx])
9109          {
9110             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9111             {
9112                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9113                   break;
9114                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9115                   break;
9116                case ProtocolIE_ID_id_SpCell_ID:
9117                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
9118                   break;
9119                case ProtocolIE_ID_id_ServCellIndex:
9120                   break;
9121                case ProtocolIE_ID_id_SpCellULConfigured:
9122                   break;
9123                case ProtocolIE_ID_id_CUtoDURRCInformation:
9124
9125                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
9126                   break;
9127                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9128
9129                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
9130                   break;
9131                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9132
9133                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
9134                   break;
9135                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9136
9137                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
9138                   break;
9139                case ProtocolIE_ID_id_RRCContainer:
9140                   {
9141
9142                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
9143                      {
9144
9145                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
9146                      }
9147                      break;
9148                   }
9149                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
9150                   break;
9151                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
9152                   {
9153                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
9154                      {
9155                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
9156                      }
9157                      break;
9158                   }
9159                default:
9160                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
9161             }
9162             free(ueSetReq->protocolIEs.list.array[ieIdx]);
9163          }
9164       }
9165       free(ueSetReq->protocolIEs.list.array);
9166    }
9167 }
9168 /*******************************************************************
9169  *
9170  * @brief Process UE context setup request from CU
9171  *
9172  * @details
9173  *
9174  *    Function : procF1UeContextSetupReq
9175  *
9176  *    Functionality: Process UE context setup request from CU
9177  *
9178  * @params[in] F1AP message
9179  * @return ROK     - success
9180  *         RFAILED - failure
9181  *
9182  * ****************************************************************/
9183 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
9184 {
9185    uint8_t  ret, ieIdx, ueIdx, lcId, cellIdx;
9186    bool ueCbFound = false;
9187    uint32_t gnbCuUeF1apId, gnbDuUeF1apId, bitRateSize;
9188    DuUeCb   *duUeCb = NULLP;
9189    UEContextSetupRequest_t   *ueSetReq = NULLP;
9190
9191    ret = ROK;
9192
9193    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9194    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
9195    {
9196       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9197       {
9198          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9199             {
9200                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
9201                break;
9202             }
9203          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9204             {
9205                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
9206                break;
9207             }
9208          case ProtocolIE_ID_id_ServCellIndex:
9209             {
9210                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
9211                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9212                {
9213                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
9214                      (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
9215                   {
9216                      ueCbFound = true;
9217                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
9218                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
9219                      if(duUeCb->f1UeDb)
9220                      {
9221                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
9222                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
9223                         duUeCb->f1UeDb->cellIdx = cellIdx;
9224                      }
9225                      else
9226                      {
9227                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
9228                         ret = RFAILED;
9229                      }
9230                   }
9231                   else
9232                      ueCbFound = false;
9233
9234                }
9235                if(!ueCbFound)
9236                {
9237                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
9238                   ret = RFAILED;
9239                }
9240                break;
9241             }
9242          case ProtocolIE_ID_id_SpCellULConfigured:
9243             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
9244             UL, SUL or UL+SUL for the indicated cell for the UE */
9245             break;
9246          case ProtocolIE_ID_id_CUtoDURRCInformation:
9247             {
9248                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
9249                {
9250                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
9251                      extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
9252                         uE_CapabilityRAT_ContainerList, duUeCb);
9253                }
9254                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
9255                {
9256                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
9257                      value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
9258                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
9259                   {
9260                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
9261                      //TODO: Update the failure cause in ue context Setup Response
9262                      ret = RFAILED;
9263                   }
9264                }
9265                break;
9266             }
9267          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9268             {
9269                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
9270             break;
9271             }
9272          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9273             {
9274                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
9275                   &duUeCb->f1UeDb->duUeCfg))
9276                {
9277                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
9278                   //TODO: Update the failure cause in ue context Setup Response
9279                   ret = RFAILED;
9280                }
9281                break;
9282             }
9283          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9284             {
9285                lcId = getDrbLcId(&duUeCb->drbBitMap);
9286                if(lcId != RFAILED)
9287                {
9288                   if(extractDrbListToSetup(lcId, &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List,\
9289                      &duUeCb->f1UeDb->duUeCfg))
9290                   {
9291                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
9292                      //TODO: Update the failure cause in ue context Setup Response
9293                      ret = RFAILED;
9294                   }
9295                }
9296                else
9297                   ret = RFAILED;
9298                break;
9299             }
9300          case ProtocolIE_ID_id_RRCContainer:
9301             {
9302                /* Filling Dl RRC Msg Info */
9303                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
9304                if(!duUeCb->f1UeDb->dlRrcMsg)
9305                {
9306                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
9307                   ret = RFAILED;
9308                }
9309                else
9310                {
9311                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
9312                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
9313                      &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
9314                }
9315                break;
9316             }
9317          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
9318             {
9319                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
9320                {
9321                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
9322                }
9323                else
9324                {
9325                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
9326                }
9327                break;
9328             }
9329          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
9330              {
9331                /* MaximumBitRate Uplink */
9332                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
9333                if(bitRateSize > 0)
9334                {
9335                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
9336                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
9337                   {
9338                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
9339                      ret = RFAILED;
9340                   }
9341                   else
9342                   {
9343                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
9344                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
9345                      ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
9346                      duUeCb->f1UeDb->duUeCfg.ambrCfg->dlBr = 0;
9347                   }
9348                }
9349                else
9350                   ret = RFAILED;
9351                break;
9352             }
9353          default:
9354             {
9355                break;
9356             }
9357       }
9358    }
9359    if(ret == RFAILED)
9360    {
9361       /*TODO : Negative case*/
9362       // BuildAndSendUeContextSetupRsp(ueIdx, cellId);
9363       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
9364    }
9365    else
9366       ret = duProcUeContextSetupRequest(duUeCb);
9367
9368    freeAperDecodeF1UeContextSetupReq(ueSetReq);
9369    return ret;
9370
9371 }
9372
9373 /*******************************************************************
9374  * @brief Free the memory allocated for UE Setup response
9375  *
9376  * @details
9377  *
9378  *    Function : FreeUeContextSetupRsp
9379  *
9380  *    Functionality:
9381  *       Free the memory allocated for UE Setup response
9382  *
9383  * @params[in] F1AP PDU for UE setup response
9384  * @return ROK     - success
9385  *         RFAILED - failure
9386  *
9387  * ****************************************************************/
9388 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
9389 {
9390    uint8_t idx;
9391    UEContextSetupResponse_t *ueSetRsp = NULLP;
9392
9393    if(f1apMsg)
9394    {
9395       if(f1apMsg->choice.successfulOutcome)
9396       {
9397          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
9398                     UEContextSetupResponse;
9399          if(ueSetRsp->protocolIEs.list.array)
9400          {
9401             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
9402             {
9403                if(ueSetRsp->protocolIEs.list.array[idx])
9404                {
9405                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
9406                   {
9407                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9408                         break;
9409                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9410                         break;
9411                      case ProtocolIE_ID_id_DUtoCURRCInformation:
9412                         {
9413                            CellGroupConfig_t *cellGrpCfg = NULLP;
9414                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
9415                                          DUtoCURRCInformation.cellGroupConfig;
9416                            if(cellGrpCfg->buf != NULLP)
9417                            {
9418                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
9419                               cellGrpCfg = NULLP;
9420                            }
9421                            break;
9422                         }
9423                      default:
9424                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
9425                         ueSetRsp->protocolIEs.list.array[idx]->id);
9426                         break;
9427                   }
9428                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
9429                         sizeof(UEContextSetupResponseIEs_t));
9430                }
9431             }
9432             DU_FREE(ueSetRsp->protocolIEs.list.array, \
9433                   ueSetRsp->protocolIEs.list.size);
9434          }
9435          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9436       }
9437       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9438    }
9439 }
9440
9441 /*******************************************************************
9442  *
9443  * @brief Builds Ue context Setup Rsp DU To CU Info
9444  *
9445  * @details
9446  *
9447  *    Function : EncodeUeCntxtDuToCuInfo
9448  *
9449  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
9450  *
9451  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
9452  *
9453  * @return ROK     - success
9454  *         RFAILED - failure
9455  *
9456  ******************************************************************/
9457
9458 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
9459 {
9460    asn_enc_rval_t        encRetVal;
9461
9462    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
9463    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
9464    encBufSize = 0;
9465    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
9466    /* Encode results */
9467    if(encRetVal.encoded == ENCODE_FAIL)
9468    {
9469       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
9470             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9471       return RFAILED;
9472    }
9473    else
9474    {
9475       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
9476       for(int i=0; i< encBufSize; i++)
9477       {
9478          printf("%x",encBuf[i]);
9479       }
9480    }
9481    duToCuCellGrp->size = encBufSize;
9482    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
9483    if(!duToCuCellGrp->buf)
9484    {
9485       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
9486    }
9487    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
9488    return ROK;
9489 }
9490
9491 /*******************************************************************
9492  *
9493  * @brief Builds and sends the UE Setup Response
9494  *
9495  * @details
9496  *
9497  *    Function : BuildAndSendUeContextSetupRsp
9498  *
9499  *    Functionality: Constructs the UE Setup Response and sends
9500  *                   it to the DU through SCTP.
9501  *
9502  * @params[in]
9503  *
9504  * @return ROK     - success
9505  *         RFAILED - failure
9506  *
9507  * ****************************************************************/
9508 uint8_t BuildAndSendUeContextSetupRsp(uint8_t ueIdx, uint8_t cellId)
9509 {
9510    uint8_t   idx, ret, cellIdx, elementCnt;
9511    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
9512    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
9513    asn_enc_rval_t  encRetVal;        /* Encoder return value */
9514    F1AP_PDU_t               *f1apMsg = NULLP;
9515    UEContextSetupResponse_t *ueSetRsp = NULLP;
9516    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
9517    DuUeCb                   *ueCb = NULLP;
9518
9519    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
9520
9521    while(true)
9522    {
9523       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9524       if(f1apMsg == NULLP)
9525       {
9526          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9527          ret = RFAILED;
9528          break;
9529       }
9530
9531       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
9532       DU_ALLOC(f1apMsg->choice.successfulOutcome,
9533             sizeof(SuccessfulOutcome_t));
9534       if(f1apMsg->choice.successfulOutcome == NULLP)
9535       {
9536          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
9537          ret = RFAILED;
9538          break;
9539       }
9540
9541       f1apMsg->choice.successfulOutcome->procedureCode = \
9542                                                          ProcedureCode_id_UEContextSetup;
9543       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
9544       f1apMsg->choice.successfulOutcome->value.present = \
9545                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
9546
9547       ueSetRsp =
9548          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9549       elementCnt = 3;
9550       ueSetRsp->protocolIEs.list.count = elementCnt;
9551       ueSetRsp->protocolIEs.list.size = \
9552                                         elementCnt * sizeof(UEContextSetupResponse_t *);
9553
9554       /* Initialize the UESetup members */
9555       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
9556             ueSetRsp->protocolIEs.list.size);
9557       if(ueSetRsp->protocolIEs.list.array == NULLP)
9558       {
9559          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
9560          ret = RFAILED;
9561          break;
9562       }
9563
9564       for(idx=0; idx<elementCnt; idx++)
9565       {
9566          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
9567                sizeof(UEContextSetupResponseIEs_t));
9568          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
9569          {
9570             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
9571             ret = RFAILED;
9572             break;
9573          }
9574       }
9575       /* Fetching Ue Cb Info*/
9576       GET_CELL_IDX(cellId, cellIdx);
9577       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
9578       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
9579       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
9580
9581       idx = 0;
9582       /*GNB CU UE F1AP ID*/
9583       ueSetRsp->protocolIEs.list.array[idx]->id = \
9584                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
9585       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9586       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
9587                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
9588       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
9589
9590       /*GNB DU UE F1AP ID*/
9591       idx++;
9592       ueSetRsp->protocolIEs.list.array[idx]->id = \
9593                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
9594       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9595       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
9596                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
9597       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
9598
9599
9600       /*DUtoCURRC Information */
9601       idx++;
9602       ueSetRsp->protocolIEs.list.array[idx]->id  = \
9603                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
9604       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9605       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
9606                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
9607       if(ueCb->f1UeDb)
9608       {
9609          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
9610          {
9611             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
9612             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
9613                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
9614             /* Free UeContext Db created during Ue context Req */
9615             freeF1UeDb(ueCb->f1UeDb);
9616             ueCb->f1UeDb = NULLP;
9617          }
9618       }
9619       else
9620       {
9621          DU_LOG("\nERROR  -->  F1AP: Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
9622          ret = RFAILED;
9623       }
9624       if(ret == RFAILED)
9625          break;
9626
9627       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9628
9629       /* Encode the UE context setup response type as APER */
9630       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
9631       encBufSize = 0;
9632       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
9633             encBuf);
9634       /* Encode results */
9635       if(encRetVal.encoded == ENCODE_FAIL)
9636       {
9637          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9638                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9639          ret = RFAILED;
9640          break;
9641       }
9642       else
9643       {
9644          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Request\n");
9645          for(int i=0; i< encBufSize; i++)
9646          {
9647             printf("%x",encBuf[i]);
9648          }
9649       }
9650
9651       /* Sending  msg  */
9652       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
9653       {
9654          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9655          ret = RFAILED;
9656          break;
9657       }
9658       break;
9659    }
9660    FreeUeContextSetupRsp(f1apMsg);
9661    return ret;
9662 }/* End of BuildAndSendUeContextSetupRsp */
9663 /*******************************************************************
9664 *
9665 * @brief  Build And Send Ue Context Rsp
9666 *
9667 * @details
9668 *
9669 *    Function : BuildAndSendUeCtxtRsp
9670 *
9671 *    Functionality : Build And Send Ue Context Rsp
9672
9673 * @params[in]
9674 * @return sucess = ROK
9675 *         failure = RFAILED
9676 *
9677 * ****************************************************************/
9678 uint8_t BuildAndSendUeCtxtRsp(uint8_t ueIdx, uint8_t cellId)
9679 {
9680    uint8_t cellIdx = 0, actionType = 0;
9681
9682    GET_CELL_IDX(cellId, cellIdx);
9683    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
9684
9685    switch(actionType)
9686    {
9687       case UE_CTXT_SETUP:
9688          BuildAndSendUeContextSetupRsp(ueIdx, cellId);
9689          break;
9690       case UE_CTXT_MOD:
9691          //TODO: Build Ue context Modification Rsp
9692          break;
9693       default:
9694          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
9695          break;
9696
9697    }
9698    return ROK;
9699 }
9700
9701 /*******************************************************************
9702  *
9703  * @brief deallocating the memory of  F1reset msg
9704  *
9705  * @details
9706  *
9707  *    Function : FreeF1ResetReq
9708  *
9709  *    Functionality :
9710  *         - freeing memory of F1reset request msg
9711  *
9712  * @params[in]
9713  * @return void
9714  *
9715  *
9716  * ****************************************************************/
9717 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
9718 {
9719    uint8_t idx =0 ;
9720    Reset_t *f1ResetMsg;
9721
9722    if(f1apMsg)
9723    {
9724       if(f1apMsg->choice.initiatingMessage)
9725       {
9726          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
9727
9728          if(f1ResetMsg->protocolIEs.list.array)
9729          {
9730             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
9731             {
9732                if(f1ResetMsg->protocolIEs.list.array[idx])
9733                {
9734                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
9735                }
9736             }
9737             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
9738          }
9739          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
9740       }
9741       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9742    }
9743 }
9744 /*******************************************************************
9745  *
9746  * @brief Build and Send F1reset request
9747  *
9748  * @details
9749  *
9750  *    Function : BuildAndSendF1ResetReq
9751  *
9752  *    Functionality:
9753  *         - Build and Send F1reset request msg
9754  *
9755  * @params[in]
9756  * @return ROK     - success
9757  *         RFAILED - failure
9758  *
9759  * ****************************************************************/
9760 uint8_t BuildAndSendF1ResetReq()
9761 {
9762    uint8_t          elementCnt=0;
9763    uint8_t          idx=0;
9764    uint8_t          ret= RFAILED;
9765    Reset_t          *f1ResetMsg = NULLP;
9766    F1AP_PDU_t       *f1apMsg = NULLP;
9767    asn_enc_rval_t   encRetVal;
9768    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
9769    do
9770    {
9771       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9772       if(f1apMsg == NULLP)
9773       {
9774          break;
9775       }
9776       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
9777       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
9778       if(f1apMsg->choice.initiatingMessage == NULLP)
9779       {
9780          break;
9781       }
9782       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
9783       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
9784       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
9785
9786       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
9787
9788       elementCnt = 3;
9789       f1ResetMsg->protocolIEs.list.count = elementCnt;
9790       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
9791
9792       /* Initialize the F1Setup members */
9793       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
9794       if(f1ResetMsg->protocolIEs.list.array == NULLP)
9795       {
9796          break;
9797       }
9798       for(idx=0; idx<elementCnt; idx++)
9799       {
9800          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
9801          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
9802          {
9803             break;
9804          }
9805       }
9806
9807       /*TransactionID*/
9808       idx=0;
9809       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9810       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9811       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
9812       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
9813
9814       /*Cause*/
9815       idx++;
9816       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
9817       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9818       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
9819       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
9820       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
9821
9822       /*Reset Type*/
9823       idx++;
9824       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
9825       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9826       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
9827       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
9828       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
9829
9830       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9831
9832       /* Encode the F1SetupRequest type as APER */
9833       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9834       encBufSize = 0;
9835       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
9836             encBuf);
9837
9838       /* Encode results */
9839       if(encRetVal.encoded == ENCODE_FAIL)
9840       {
9841          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
9842                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9843          break;
9844       }
9845       else
9846       {
9847          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
9848          for(idx=0; idx< encBufSize; idx++)
9849          {
9850             printf("%x",encBuf[idx]);
9851          }
9852       }
9853
9854       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
9855       {
9856          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
9857          break;
9858       }
9859
9860       ret = ROK;
9861       break;
9862    }while(true);
9863
9864    FreeF1ResetReq(f1apMsg);
9865    return ret;
9866 }
9867 /*******************************************************************
9868  *
9869  * @brief Build And Send F1ResetAck
9870  *
9871  * @details
9872  *
9873  *    Function : BuildAndSendF1ResetAck
9874  *
9875  *    Functionality:
9876  *         - Build And Send  F1ResetRSP
9877  *
9878  * @return ROK     - success
9879  *         RFAILED - failure
9880  *
9881  * ****************************************************************/
9882 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9883 {
9884    uint8_t idx;
9885    ResetAcknowledge_t *f1ResetAck;
9886
9887    if(f1apMsg)
9888    {
9889       if(f1apMsg->choice.successfulOutcome)
9890       {
9891          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9892
9893          if(f1ResetAck->protocolIEs.list.array)
9894          {
9895             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9896             {
9897                if(f1ResetAck->protocolIEs.list.array[idx])
9898                {
9899                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9900                }
9901             }
9902             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9903          }
9904          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9905       }
9906       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9907    }
9908 }
9909
9910 /*******************************************************************
9911  *
9912  * @brief Build And Send F1ResetAck
9913  *
9914  * @details
9915  *
9916  *    Function : BuildAndSendF1ResetAck
9917  *
9918  *    Functionality:
9919  *         - Build And Send  F1ResetRSP
9920  *
9921  *  @params[in]
9922  * @return ROK     - success
9923  *         RFAILED - failure
9924  *
9925  * ****************************************************************/
9926 uint8_t BuildAndSendF1ResetAck()
9927 {
9928    uint8_t                idx = 0;
9929    uint8_t                elementCnt = 0;
9930    uint8_t                ret = RFAILED;
9931    F1AP_PDU_t             *f1apMsg = NULL;
9932    ResetAcknowledge_t     *f1ResetAck = NULLP;
9933    asn_enc_rval_t         encRetVal;
9934    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
9935
9936    do{
9937       /* Allocate the memory for F1ResetRequest_t */
9938       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9939       if(f1apMsg == NULLP)
9940       {
9941          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9942          break;
9943       }
9944
9945       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9946
9947       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9948       if(f1apMsg->choice.successfulOutcome == NULLP)
9949       {
9950          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9951          break;
9952       }
9953       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9954       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9955       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9956
9957       elementCnt = 1;
9958
9959       f1ResetAck->protocolIEs.list.count = elementCnt;
9960       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9961
9962       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9963       if(f1ResetAck->protocolIEs.list.array == NULLP)
9964       {
9965          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9966          break;
9967       }
9968
9969       for(idx=0; idx<elementCnt; idx++)
9970       {
9971          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9972          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9973          {
9974             break;
9975          }
9976       }
9977       /*TransactionID*/
9978       idx = 0;
9979       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9980       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9981       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9982       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9983
9984       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9985
9986       /* Encode the F1SetupRequest type as UPER */
9987       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9988       encBufSize = 0;
9989       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9990
9991       /* Check encode results */
9992       if(encRetVal.encoded == ENCODE_FAIL)
9993       {
9994          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9995                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9996          break;
9997       }
9998       else
9999       {
10000          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
10001          for(int i=0; i< encBufSize; i++)
10002          {
10003             printf("%x",encBuf[i]);
10004          }
10005       }
10006       /* Sending msg */
10007       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10008       {
10009          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
10010          break;
10011       }
10012
10013       ret = ROK;
10014       break;
10015    }while(true);
10016
10017    FreeF1ResetAck(f1apMsg);
10018    return ret;
10019 }
10020 /******************************************************************
10021 *
10022 * @brief free F1 reset msg allocated by aper_decoder
10023 *
10024 * @details
10025 *
10026 *    Function : freeAperDecodeF1ResetMsg
10027 *
10028 *    Functionality: free F1 reset msg allocated by aper_decoder
10029 *
10030 * @params[in] Reset_t *f1ResetMsg
10031 * @return void
10032 *
10033 * ****************************************************************/
10034
10035 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
10036 {
10037    uint8_t ieIdx =0;
10038    if(f1ResetMsg->protocolIEs.list.array)
10039    {
10040       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
10041       {
10042          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
10043          {
10044             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
10045          }
10046       }
10047       free(f1ResetMsg->protocolIEs.list.array);
10048    }
10049 }
10050
10051 /******************************************************************
10052  *
10053  * @brief Processes DL RRC Message Transfer  sent by CU
10054  *
10055  * @details
10056  *
10057  *    Function : procF1ResetReq
10058  *
10059  *    Functionality: Processes DL RRC Message Transfer sent by CU
10060  *
10061  * @params[in] F1AP_PDU_t ASN decoded F1AP message
10062  * @return ROK     - success
10063  *         RFAILED - failure
10064  *
10065  * ****************************************************************/
10066 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
10067 {
10068    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
10069    uint8_t       ieIdx = 0;
10070    uint8_t        ret = ROK;
10071    Reset_t       *f1ResetMsg = NULLP;
10072
10073    DU_LOG("\nINFO   -->  Processing F1 reset request");
10074    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10075
10076    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
10077    {
10078       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
10079       {
10080          case ProtocolIE_ID_id_TransactionID:
10081             break;
10082
10083          case ProtocolIE_ID_id_Cause:
10084             break;
10085
10086          case ProtocolIE_ID_id_ResetType:
10087             {
10088                break;
10089             }
10090
10091          default:
10092             break;
10093       }
10094    }
10095    ret = BuildAndSendF1ResetAck();
10096    DU_LOG("\nINFO   -->  UE release is not supported for now");
10097
10098    freeAperDecodeF1ResetMsg(f1ResetMsg);
10099
10100    return ret;
10101 }
10102
10103 /*******************************************************************
10104  *
10105  * @brief free the RRC delivery report
10106  *
10107  * @details
10108  *
10109  *    Function : freeRrcDeliveryReport
10110  *
10111  *    Functionality: free the RRC delivery report
10112  *
10113  * @params[in]
10114  * @return ROK     - success
10115  *         RFAILED - failure
10116  *
10117  * ****************************************************************/
10118 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
10119 {
10120    uint8_t idx=0;
10121    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
10122
10123    if(f1apMsg)
10124    {
10125       if(f1apMsg->choice.initiatingMessage)
10126       {
10127          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
10128          if(rrcDeliveryReport->protocolIEs.list.array)
10129          {
10130             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
10131                   idx++)
10132             {
10133                if(rrcDeliveryReport->protocolIEs.list.array[idx])
10134                {
10135                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
10136                         sizeof(RRCDeliveryReportIEs_t));
10137                }
10138             }
10139             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
10140                   rrcDeliveryReport->protocolIEs.list.size);
10141          }
10142          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
10143       }
10144       DU_FREE(f1apMsg,
10145             sizeof(F1AP_PDU_t));
10146    }
10147 }
10148
10149 /*******************************************************************
10150 *
10151 * @brief Builds and sends the RRC delivery report
10152 *
10153 * @details
10154 *
10155 *    Function : BuildAndSendRrcDeliveryReport
10156 *
10157 *    Functionality: Builds and sends the RRC delivery report
10158 *
10159 * @params[in]
10160 *
10161 * @return ROK     - success
10162 *         RFAILED - failure
10163 *
10164 * ****************************************************************/
10165 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
10166    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
10167 {
10168    uint8_t             ret = RFAILED;
10169    uint8_t             idx    = 0;
10170    uint8_t             idx1   = 0;
10171    uint8_t             elementCnt = 0;
10172    F1AP_PDU_t          *f1apMsg = NULLP;
10173    asn_enc_rval_t      encRetVal;
10174    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
10175
10176    do{
10177
10178       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
10179       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10180       if(f1apMsg == NULLP)
10181       {
10182          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10183          break;
10184       }
10185       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
10186       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
10187       if(f1apMsg->choice.initiatingMessage == NULLP)
10188       {
10189          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
10190          break;
10191       }
10192       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
10193       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
10194       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
10195
10196       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
10197       elementCnt = 4;
10198       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
10199       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
10200
10201       /* Initialize the F1Setup members */
10202       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
10203       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
10204       {
10205          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
10206          break;
10207       }
10208       for(idx =0 ;idx <elementCnt; idx++)
10209       {
10210          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
10211          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
10212          {
10213             break;
10214          }
10215       }
10216
10217       idx1 = 0;
10218
10219       /*GNB CU UE F1AP ID*/
10220       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10221       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
10222       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
10223       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10224
10225       /*GNB DU UE F1AP ID*/
10226       idx1++;
10227       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10228       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
10229       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
10230       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10231
10232       /*RRC delivery status*/
10233       idx1++;
10234       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
10235       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
10236       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
10237       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
10238       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
10239       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
10240       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
10241
10242       /* SRB ID */
10243       idx1++;
10244       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
10245       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
10246       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
10247       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
10248
10249       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10250
10251       /* Encode the RRC DELIVERY REPORT type as APER */
10252       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10253       encBufSize = 0;
10254       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10255             encBuf);
10256
10257       /* Encode results */
10258       if(encRetVal.encoded == ENCODE_FAIL)
10259       {
10260          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
10261                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10262          break;
10263       }
10264       else
10265       {
10266          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
10267          for(idx=0; idx< encBufSize; idx++)
10268          {
10269             printf("%x",encBuf[idx]);
10270          }
10271       }
10272
10273       /* Sending msg */
10274       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10275       {
10276          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
10277          break;
10278       }
10279       ret = ROK;
10280       break;
10281
10282    }while(true);
10283
10284    freeRrcDeliveryReport(f1apMsg);
10285    return ret;
10286 }
10287
10288 /*******************************************************************
10289  *
10290  * @brief Processes cells to be activated
10291  *
10292  * @details
10293  *
10294  *    Function : extractCellsToBeActivated
10295  *
10296  *    Functionality:
10297  *      - Processes cells to be activated list received in F1SetupRsp
10298  *
10299  * @params[in] void
10300  * @return ROK     - success
10301  *         RFAILED - failure
10302  *
10303  * ****************************************************************/
10304
10305 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
10306 {
10307    uint8_t  ret = ROK;
10308    uint16_t idx, nci, pci = 0;
10309    Cells_to_be_Activated_List_Item_t cell;
10310
10311    for(idx=0; idx<cellsToActivate.list.count; idx++)
10312    {
10313       nci = 0;
10314       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
10315       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
10316
10317       if(cell.nRPCI)
10318       {
10319          pci = *cell.nRPCI;
10320       }
10321       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
10322    }
10323    return ret;
10324 }
10325 /******************************************************************
10326 *
10327 * @brief Processes F1 Setup Response allocated by aper_decoder
10328 *
10329 * @details
10330 *
10331 *    Function : freeF1SetupRsp
10332 *
10333 *    Functionality: free F1 Setup Response allocated by aper_decoder
10334 *
10335 * @params[in] F1SetupResponse_t *f1SetRspMsg
10336 * @return void
10337 *
10338 * ****************************************************************/
10339
10340 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
10341 {
10342    uint8_t ieIdx =0;
10343    uint8_t arrIdx =0;
10344    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
10345    RRC_Version_t      *rrcVer =NULLP;
10346
10347    if(f1SetRspMsg->protocolIEs.list.array)
10348    {
10349       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
10350       {
10351          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
10352          {
10353             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
10354             {
10355                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
10356                   {
10357                      cellToActivate =
10358                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
10359                      if(cellToActivate->list.array)
10360                      {
10361                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
10362                         {
10363                            if(cellToActivate->list.array[arrIdx])
10364                            {
10365
10366                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
10367                               pLMN_Identity.buf)
10368                               {
10369                                  if(cellToActivate->list.array[0]->value.choice.\
10370                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
10371                                  {
10372                                     free(cellToActivate->list.array[0]->value.choice.\
10373                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
10374                                  }
10375
10376                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
10377                                        nRCGI.pLMN_Identity.buf);
10378                               }
10379                               free(cellToActivate->list.array[arrIdx]);
10380                            }
10381                         }
10382                         free(cellToActivate->list.array);
10383                      }
10384                      break;
10385                   }
10386                case ProtocolIE_ID_id_TransactionID:
10387                   {
10388                      break;
10389                   }
10390                case ProtocolIE_ID_id_gNB_CU_Name:
10391                   {
10392                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
10393                      break;
10394                   }
10395                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
10396                   {
10397                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
10398                      if(rrcVer->latest_RRC_Version.buf)
10399                      {
10400                         if(rrcVer->iE_Extensions)
10401                         {
10402                            if(rrcVer->iE_Extensions->list.array)
10403                            {
10404                               if(rrcVer->iE_Extensions->list.array[0])
10405                               {
10406                                  if(rrcVer->iE_Extensions->list.\
10407                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
10408                                  {
10409                                     free(rrcVer->iE_Extensions->list.\
10410                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
10411                                  }
10412                                  free(rrcVer->iE_Extensions->list.array[0]);
10413                               }
10414                               free(rrcVer->iE_Extensions->list.array);
10415                            }
10416                            free(rrcVer->iE_Extensions);
10417                         }
10418                         free(rrcVer->latest_RRC_Version.buf);
10419                      }
10420                      break;
10421
10422                   }
10423                default:
10424                   {
10425                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
10426                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
10427                   }
10428             }
10429             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
10430          }
10431       }
10432       free(f1SetRspMsg->protocolIEs.list.array);
10433    }
10434 }
10435 /******************************************************************
10436  *
10437  * @brief Processes F1 Setup Response sent by CU
10438  *
10439  * @details
10440  *
10441  *    Function : procF1SetupRsp
10442  *
10443  *    Functionality: Processes F1 Setup Response sent by CU
10444  *
10445  * @params[in] F1AP_PDU_t ASN decoded F1AP message
10446  * @return ROK     - success
10447  *         RFAILED - failure
10448  *
10449  * ****************************************************************/
10450 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
10451 {
10452    uint8_t ret = ROK;
10453    uint16_t idx =0;
10454    F1SetupResponse_t *f1SetRspMsg = NULLP;
10455    GNB_CU_Name_t     *cuName = NULLP;
10456    F1SetupRsp  f1SetRspDb;
10457    RRC_Version_t      *rrcVer =NULLP;
10458
10459    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
10460
10461    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
10462    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
10463
10464    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
10465    {
10466       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
10467       {
10468          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
10469             {
10470                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
10471                      value.choice.Cells_to_be_Activated_List);
10472                break;
10473             }
10474          case ProtocolIE_ID_id_TransactionID:
10475             {
10476                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
10477                                     value.choice.TransactionID;
10478                break;
10479             }
10480          case ProtocolIE_ID_id_gNB_CU_Name:
10481             {
10482                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
10483                         value.choice.GNB_CU_Name;
10484                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
10485                break;
10486             }
10487          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
10488             {
10489                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
10490                strcpy(f1SetRspDb.rrcVersion.rrcVer,
10491                      (const char*)rrcVer->latest_RRC_Version.buf);
10492                break;
10493             }
10494          default:
10495             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
10496                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
10497       }
10498       duProcF1SetupRsp();
10499    }
10500
10501    freeAperDecodeF1SetupRsp(f1SetRspMsg);
10502    return ret;
10503 }
10504 /*******************************************************************
10505 *
10506 * @brief free GNB DU config update ack
10507 *
10508 * @details
10509 *
10510 *    Function : freeAperDecodeGnbDuAck
10511 *
10512 *    Functionality: Processes GNB DU config update ack And
10513 *                     added free part for the memory allocated by aper_decoder
10514 *
10515 * @params[in] F1AP_PDU_t ASN decoded F1AP message
10516 * @return ROK     - success
10517 *         RFAILED - failure
10518 *
10519 * ****************************************************************/
10520
10521 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
10522 {
10523    uint8_t ieIdx = 0;
10524
10525    if(gnbDuAck->protocolIEs.list.array)
10526    {
10527       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
10528       {
10529          if(gnbDuAck->protocolIEs.list.array[ieIdx])
10530          {
10531             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
10532          }
10533       }
10534       free(gnbDuAck->protocolIEs.list.array);
10535    }
10536 }
10537 /*******************************************************************
10538 *
10539 * @brief Processes GNB DU config update ack
10540 *
10541 * @details
10542 *
10543 *    Function : procF1GNBDUCfgUpdAck
10544 *
10545 *    Functionality: added free part for the memory allocated by aper_decoder
10546 *
10547 * @params[in] F1AP_PDU_t *f1apMsg
10548 * @return void
10549 *
10550 * ****************************************************************/
10551 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
10552 {
10553    uint8_t ieIdx;
10554    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
10555
10556    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
10557    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
10558
10559    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
10560    {
10561       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
10562       {
10563          case ProtocolIE_ID_id_TransactionID:
10564             break;
10565          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
10566             break;
10567          default :
10568             DU_LOG("\nERROR  -->  F1AP: Invalid IE Received: %ld, at procF1GNBDUCfgUpdAck()", \
10569             gnbDuAck->protocolIEs.list.array[ieIdx]->id);
10570             break;
10571       }
10572    }
10573    duProcGnbDuCfgUpdAckMsg();
10574 #if 0
10575    if(BuildAndSendF1ResetReq() != ROK)
10576    {
10577       return RFAILED;
10578    }
10579 #endif
10580
10581    freeAperDecodeGnbDuAck(gnbDuAck);
10582    return ROK;
10583 }
10584 /******************************************************************
10585 *
10586 * @brief free DL RRC Message Transfer allocated by aper_decoder
10587 *
10588 * @details
10589 *
10590 *    Function : freeAperDecodef1DlRrcMsg
10591 *
10592 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
10593 *
10594 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
10595 * @return ROK     - success
10596 *         RFAILED - failure
10597 *
10598 * ****************************************************************/
10599
10600 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
10601 {
10602    uint8_t ieIdx =0;
10603    RRCContainer_t *rrcContainer = NULLP;
10604
10605    if(f1DlRrcMsg->protocolIEs.list.array)
10606    {
10607       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
10608       {
10609          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
10610          {
10611             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
10612             {
10613                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10614                   break;
10615                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10616                   break;
10617                case ProtocolIE_ID_id_SRBID:
10618                   break;
10619                case ProtocolIE_ID_id_RRCContainer:
10620                   {
10621                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
10622                      free(rrcContainer->buf);
10623                   }
10624                case ProtocolIE_ID_id_ExecuteDuplication:
10625                   break;
10626                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10627                   break;
10628                   break;
10629             }
10630             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
10631          }
10632       }
10633       free(f1DlRrcMsg->protocolIEs.list.array);
10634    }
10635 }
10636 /******************************************************************
10637  *
10638  * @brief Processes DL RRC Message Transfer  sent by CU
10639  *
10640  * @details
10641  *
10642  *    Function : procF1DlRrcMsgTrans
10643  *
10644  *    Functionality: Processes DL RRC Message Transfer sent by CU
10645  *
10646  * @params[in] F1AP_PDU_t ASN decoded F1AP message
10647  * @return ROK     - success
10648  *         RFAILED - failure
10649  *
10650  * ****************************************************************/
10651 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
10652 {
10653    uint8_t  idx, ret;
10654    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
10655    F1DlRrcMsg dlMsg;
10656    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
10657
10658    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
10659    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
10660
10661    ret = ROK;
10662
10663    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
10664    {
10665       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
10666       {
10667          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10668             {
10669                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
10670                break;
10671             }
10672          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10673             {
10674                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
10675                break;
10676             }
10677          case ProtocolIE_ID_id_SRBID:
10678             {
10679                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
10680                break;
10681             }
10682          case ProtocolIE_ID_id_ExecuteDuplication:
10683             dlMsg.execDup = true;
10684             break;
10685
10686          case ProtocolIE_ID_id_RRCContainer:
10687             {
10688                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
10689                {
10690                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
10691                   DU_ALLOC(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
10692                   if(dlMsg.rrcMsgPdu)
10693                   {
10694                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
10695                         dlMsg.rrcMsgSize);
10696                   }
10697                   else
10698                   {
10699                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
10700                      return RFAILED;
10701                   }
10702                }
10703                else
10704                {
10705                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
10706                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
10707                   return RFAILED;
10708                }
10709                break;
10710             }
10711          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10712             {
10713                dlMsg.deliveryStatRpt = true;
10714                break;
10715             }
10716          default:
10717             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
10718                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
10719       }
10720    }
10721
10722    ret = duProcDlRrcMsg(&dlMsg);
10723
10724    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
10725    return ret;
10726 }
10727
10728 /*****************************************************************i
10729  *
10730  * @brief Handles received F1AP message and sends back response
10731  *
10732  * @details
10733  *
10734  *    Function : F1APMsgHdlr
10735  *
10736  *    Functionality:
10737  *         - Decodes received F1AP control message
10738  *         - Prepares response message, encodes and sends to SCTP
10739  *
10740  * @params[in]
10741  * @return ROK     - success
10742  *         RFAILED - failure
10743  *
10744  * ****************************************************************/
10745 void F1APMsgHdlr(Buffer *mBuf)
10746 {
10747    int i =0;
10748    char *recvBuf =NULLP;
10749    MsgLen copyCnt =0;
10750    MsgLen recvBufLen =0;
10751    F1AP_PDU_t *f1apMsg =NULLP;
10752    asn_dec_rval_t rval; /* Decoder return value */
10753    F1AP_PDU_t f1apasnmsg ;
10754    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
10755    ODU_PRINT_MSG(mBuf, 0,0);
10756
10757    /* Copy mBuf into char array to decode it */
10758    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
10759    DU_ALLOC(recvBuf, (Size)recvBufLen);
10760
10761    if(recvBuf == NULLP)
10762    {
10763       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
10764       return;
10765    }
10766    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
10767    {
10768       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
10769       return;
10770    }
10771
10772    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
10773    for(i=0; i< recvBufLen; i++)
10774    {
10775       printf("%x",recvBuf[i]);
10776    }
10777
10778    /* Decoding flat buffer into F1AP messsage */
10779    f1apMsg = &f1apasnmsg;
10780    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
10781
10782    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
10783    DU_FREE(recvBuf, (Size)recvBufLen);
10784
10785    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10786    {
10787       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
10788       return;
10789    }
10790    printf("\n");
10791    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10792
10793    switch(f1apMsg->present)
10794    {
10795       case F1AP_PDU_PR_successfulOutcome:
10796          {
10797             switch(f1apMsg->choice.successfulOutcome->value.present)
10798             {
10799                case SuccessfulOutcome__value_PR_ResetAcknowledge:
10800                   {
10801                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
10802                      break;
10803                   }
10804                case SuccessfulOutcome__value_PR_F1SetupResponse:
10805                   {
10806 #ifndef ODU_TEST_STUB
10807                      procF1SetupRsp(f1apMsg);
10808 #endif
10809                      break;
10810                   }
10811
10812                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
10813                   {
10814                      procF1GNBDUCfgUpdAck(f1apMsg);
10815                      break;
10816                   }
10817
10818                default:
10819                   {
10820                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
10821                      f1apMsg->choice.successfulOutcome->value.present);
10822                      return;
10823                   }
10824             }/* End of switch(successfulOutcome) */
10825             free(f1apMsg->choice.successfulOutcome);
10826             break;
10827          }
10828       case F1AP_PDU_PR_initiatingMessage:
10829          {
10830             switch(f1apMsg->choice.initiatingMessage->value.present)
10831             {
10832                case InitiatingMessage__value_PR_Reset:
10833                   {
10834                      procF1ResetReq(f1apMsg);
10835                      break;
10836                   }
10837                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
10838                   {
10839                      procF1DlRrcMsgTrans(f1apMsg);
10840                      break;
10841                   }
10842                case InitiatingMessage__value_PR_UEContextSetupRequest:
10843                   {
10844                      procF1UeContextSetupReq(f1apMsg);
10845                      break;
10846                   }
10847                default:
10848                   {
10849                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
10850                            f1apMsg->choice.initiatingMessage->value.present);
10851                      return;
10852                   }
10853             }/* End of switch(initiatingMessage) */
10854             free(f1apMsg->choice.initiatingMessage);
10855             break;
10856          }
10857
10858       default:
10859          {
10860             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
10861             return;
10862          }
10863          free(f1apMsg);
10864
10865    }/* End of switch(f1apMsg->present) */
10866
10867 } /* End of F1APMsgHdlr */
10868
10869 /**********************************************************************
10870   End of file
10871  **********************************************************************/