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