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