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
  21 #include "du_mgr.h"
  22 #include "du_mgr_main.h"
  23 #include "du_cell_mgr.h"
  24 #include "du_f1ap_msg_hdl.h"
  25 #include "GNB-DU-System-Information.h"
  26 #include "CellGroupConfigRrc.h"
  27 #include "MAC-CellGroupConfig.h"
  28 #include "SchedulingRequestConfig.h"
  29 #include "SchedulingRequestToAddMod.h"
  30 #include "BSR-Config.h"
  31 #include "TAG-Config.h"
  32 #include "TAG.h"
  33 #include "PHR-Config.h"
  34 #include "RLC-Config.h"
  35 #include "UL-AM-RLC.h"
  36 #include "DL-AM-RLC.h"
  37 #include "LogicalChannelConfig.h"
  38 #include "RLC-BearerConfig.h"
  39 #include "PhysicalCellGroupConfig.h"
  40 #include "SpCellConfig.h"
  41 #include "ServingCellConfig.h"
  42 #include "ControlResourceSet.h"
  43 #include "SearchSpace.h"
  44 #include "PDCCH-Config.h"
  45 #include "PDSCH-TimeDomainResourceAllocation.h"
  46 #include "PDSCH-TimeDomainResourceAllocationList.h"
  47 #include "DMRS-DownlinkConfig.h"
  48 #include "PDSCH-Config.h"
  49 #include "BWP-DownlinkDedicated.h"
  50 #include "PUSCH-TimeDomainResourceAllocation.h"
  51 #include "PUSCH-TimeDomainResourceAllocationList.h"
  52 #include "DMRS-UplinkConfig.h"
  53 #include "PUSCH-Config.h"
  54 #include "SRS-ResourceId.h"
  55 #include "SRS-Resource.h"
  56 #include "SRS-ResourceSet.h"
  57 #include "SRS-Config.h"
  58 #include "BWP-UplinkDedicated.h"
  59 #include "PUSCH-ServingCellConfig.h"
  60 #include "UplinkConfig.h"
  61 #include "PDSCH-ServingCellConfig.h"
  62 #include "DUtoCURRCContainer.h"
  63
  64 extern char encBuf[ENC_BUF_MAX_LEN];
  65 extern DuCfgParams duCfgParam;
  66 uint8_t BuildULTnlInforet=RFAILED;
  67 uint8_t ServedCellListreturn=RFAILED;
  68 S16 sctpSend(Buffer *mBuf, U8 itfType);
  69 uint8_t Nrcgiret=RFAILED;
  70 uint8_t SplCellListret=RFAILED;
  71 uint8_t SRBSetupret=RFAILED;
  72 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp);
  73
  74 /*******************************************************************
  75  *
  76  * @brief Builds Uplink Info for NR
  77  *
  78  * @details
  79  *
  80  *    Function : BuildULNRInfo
  81  *
  82  *    Functionality: Building NR Uplink Info
  83  *
  84  * @params[in] NRFreqInfo_t *ulnrfreq
  85  * @return ROK     - success
  86  *         RFAILED - failure
  87  *
  88  * ****************************************************************/
  89 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
  90 {
  91    uint8_t idx=0;
  92    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
  93                        fdd.ulNrFreqInfo.nrArfcn;
  94    ulnrfreq->freqBandListNr.list.count = 1;
  95    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
  96         DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
  97    if(ulnrfreq->freqBandListNr.list.array == NULLP)
  98    {
  99        return RFAILED;
 100    }
 101    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 102    {
 103        DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 104        if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 105       {
 106          return RFAILED;
 107            }
 108    }
 109    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 110    duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 111    freqBand[0].nrFreqBand;
 112    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 113         return ROK;
 114 }
 115 /*******************************************************************
 116  *
 117  * @brief Builds Downlink NR Info
 118  *
 119  * @details
 120  *
 121  *    Function : BuildDLNRInfo
 122  *
 123  *    Functionality: Building Downlink NR Info
 124  *
 125  * @params[in] NRFreqInfo_t *dlnrfreq
 126  * @return ROK     - success
 127  *         RFAILED - failure
 128  *
 129  * ****************************************************************/
 130 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 131 {
 132    uint8_t idx=0;
 133         dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 134                        fdd.dlNrFreqInfo.nrArfcn;
 135    dlnrfreq->freqBandListNr.list.count = 1;
 136    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 137    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 138    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 139    {
 140       return RFAILED;
 141         }
 142    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 143         {
 144            DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 145       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 146       {
 147          return RFAILED;
 148                 }
 149    }
 150    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 151    duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 152       freqBand[0].nrFreqBand;
 153    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 154
 155      return ROK;
 156 }
 157
 158 /*******************************************************************
 159  *
 160  * @brief Builds Nrcgi
 161  *
 162  * @details
 163  *
 164  *    Function : BuildNrcgi
 165  *
 166  *    Functionality: Building the PLMN ID and NR Cell id
 167  *
 168  * @params[in] NRCGI_t *nrcgi
 169  * @return ROK     - success
 170  *         RFAILED - failure
 171  *
 172  * ****************************************************************/
 173 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 174 {
 175    uint8_t ret;
 176    uint8_t unused = 4;
 177    uint8_t byteSize = 5;
 178    uint8_t val = 16;
 179    /* Allocate Buffer Memory */
 180    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 181    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 182    if(nrcgi->pLMN_Identity.buf == NULLP)
 183         {
 184            return RFAILED;
 185    }
 186         ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 187                                  &nrcgi->pLMN_Identity); // Building PLMN function
 188         if(ret != ROK)
 189    {
 190            return RFAILED;
 191    }
 192    /*nrCellIdentity*/
 193    //ret = BuildNrCellId(&nrcgi->nRCellIdentity);
 194    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 195    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 196    if(nrcgi->nRCellIdentity.buf == NULLP)
 197    {
 198            return RFAILED;
 199    }
 200    ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
 201    if(ret != ROK)
 202    {
 203                 return RFAILED;
 204    }
 205    return ROK;
 206 }
 207 /*******************************************************************
 208  *
 209  * @brief Builds FiveGStac
 210  *
 211  * @details
 212  *
 213  *    Function : BuildFiveGSTac
 214  *
 215  *    Functionality: Building the FiveGSTac
 216  *
 217  * @params[in] OCTET_STRING_t *fivegsTac
 218  * @return ROK     - success
 219  *         RFAILED - failure
 220  *
 221  * ****************************************************************/
 222 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 223 {
 224    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 225    if(servcell->fiveGS_TAC == NULLP)
 226    {
 227            return RFAILED;
 228    }
 229    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 230    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 231          sizeof(servcell->fiveGS_TAC->size));
 232    if(servcell->fiveGS_TAC->buf == NULLP)
 233    {
 234            return RFAILED;
 235    }
 236    servcell->fiveGS_TAC->buf[0] = 0;
 237    servcell->fiveGS_TAC->buf[1] = 0;
 238    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 239    return ROK;
 240 }
 241 /*******************************************************************
 242  *
 243  * @brief Builds NR Mode
 244  *
 245  * @details
 246  *
 247  *    Function : BuildNrMode
 248  *
 249  *    Functionality: Building the NR Mode
 250  *
 251  * @params[in] NR_Mode_Info_t *fdd
 252  * @return ROK     - success
 253  *         RFAILED - failure
 254  *
 255  * ****************************************************************/
 256 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 257 {
 258    uint8_t BuildDLNRInforet=0;
 259         uint8_t BuildULNRInforet=0;
 260    /* FDD Mode */
 261         mode->present = NR_Mode_Info_PR_fDD;
 262    if(mode->present == NR_Mode_Info_PR_fDD)
 263    {
 264       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 265       if(mode->choice.fDD == NULLP)
 266       {
 267                    return RFAILED;
 268       }
 269       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 270       if(BuildULNRInforet != ROK)
 271       {
 272           return RFAILED;
 273            }
 274            BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 275       if(BuildDLNRInforet != ROK)
 276       {
 277                    return RFAILED;
 278       }
 279         }
 280    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 281                                     duCfgParam.srvdCellLst[0].duCellInfo.\
 282                                     f1Mode.mode.fdd.ulTxBw.nrScs;
 283    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 284                                     duCfgParam.srvdCellLst[0].duCellInfo.\
 285                                     f1Mode.mode.fdd.ulTxBw.nrb;
 286    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 287                                     duCfgParam.srvdCellLst[0].duCellInfo.\
 288                                     f1Mode.mode.fdd.dlTxBw.nrScs;
 289    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 290                                     duCfgParam.srvdCellLst[0].duCellInfo.\
 291                                     f1Mode.mode.fdd.dlTxBw.nrb;
 292         return ROK;
 293 }
 294 /*******************************************************************
 295  *
 296  * @brief Builds IE Extensions for Served PLMNs
 297  *
 298  * @details
 299  *
 300  *    Function : BuildExtensions
 301  *
 302  *    Functionality: Building the IE Extensions
 303  *
 304  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 305  * @return ROK     - success
 306  *         RFAILED - failure
 307  *
 308  * ****************************************************************/
 309 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 310 {
 311    uint8_t idx;
 312    uint8_t plmnidx;
 313    uint8_t extensionCnt=1;
 314    uint8_t sliceId=0;
 315    uint8_t sdId;
 316    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 317    if((*ieExtend) == NULLP)
 318    {
 319            return RFAILED;
 320    }
 321    (*ieExtend)->list.count = extensionCnt;
 322    (*ieExtend)->list.size = \
 323                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 324    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 325    if((*ieExtend)->list.array == NULLP)
 326    {
 327            return RFAILED;
 328    }
 329    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 330    {
 331       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 332             sizeof(ServedPLMNs_ItemExtIEs_t));
 333       if((*ieExtend)->list.array[plmnidx] == NULLP)
 334       {
 335                    return RFAILED;
 336            }
 337    }
 338    idx = 0;
 339    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 340    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 341    (*ieExtend)->list.array[idx]->extensionValue.present = \
 342                  ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 343    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 344       list.count = 1;
 345    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 346                  list.size = sizeof(SliceSupportItem_t *);
 347     DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 348             list.array,sizeof(SliceSupportItem_t *));
 349     if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 350             list.array == NULLP)
 351     {
 352             return RFAILED;
 353     }
 354     DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 355             list.array[sliceId],sizeof(SliceSupportItem_t));
 356     if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 357             list.array[sliceId] == NULLP)
 358     {
 359              return RFAILED;
 360     }
 361    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 362          list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
 363     DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 364             .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 365             extensionValue.choice.SliceSupportList.\
 366             list.array[sliceId]->sNSSAI.sST.size);
 367    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 368             .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
 369    {
 370            return RFAILED;
 371    }
 372   (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 373          list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
 374    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 375             list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 376    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 377             list.array[sliceId]->sNSSAI.sD == NULLP)
 378    {
 379            return RFAILED;
 380    }
 381    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 382          list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
 383    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 384             list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
 385             SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 386    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 387             list.array[sliceId]->sNSSAI.sD->buf == NULLP)
 388    {
 389        return RFAILED;
 390         }
 391    sdId = 0;
 392    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 393          list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
 394       sdId++;
 395    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 396          list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
 397       sdId++;
 398    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 399          list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
 400     return ROK;
 401 }
 402 /*******************************************************************
 403  *
 404  * @brief Builds Served PLMN
 405  *
 406  * @details
 407  *
 408  *    Function : BuildServedPlmn
 409  *
 410  *    Functionality: Building the Served PLMN
 411  *
 412  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 413  * @return ROK     - success
 414  *         RFAILED - failure
 415  *
 416  * ****************************************************************/
 417 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 418 {
 419    uint8_t  plmnidx;
 420    uint8_t  servPlmnCnt=1;
 421         uint8_t buildPlmnIdret=0;
 422         uint8_t BuildExtensionsret=0;
 423    srvplmn->list.count = servPlmnCnt;
 424    srvplmn->list.size = \
 425                       servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 426         DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 427    if(srvplmn->list.array == NULLP)
 428    {
 429        return RFAILED;
 430    }
 431    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 432    {
 433       DU_ALLOC(srvplmn->list.array[plmnidx],\
 434             sizeof(ServedPLMNs_Item_t));
 435       if(srvplmn->list.array[plmnidx] == NULLP)
 436       {
 437                    return RFAILED;
 438       }
 439    }
 440         srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 441    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 442    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 443          &srvplmn->list.array[0]->pLMN_Identity);
 444    if(buildPlmnIdret!= ROK)
 445    {
 446            return RFAILED;
 447    }
 448    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 449    if(BuildExtensionsret!= ROK)
 450    {
 451            return RFAILED;
 452    }
 453    return ROK;
 454 }
 455 /*******************************************************************
 456  *
 457  * @brief Builds Served Cell List
 458  *
 459  * @details
 460  *
 461  *    Function : BuildServedCellList
 462  *
 463  *    Functionality: Building Served Cell List
 464  *
 465  * @params[in] PLMNID plmn
 466  * @return ROK     - success
 467  *         RFAILED - failure
 468  *
 469  * ****************************************************************/
 470
 471 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 472 {
 473    uint8_t  BuildNrcgiret=0;
 474    uint8_t  BuildFiveGSTacret=0;
 475         uint8_t  BuildServedPlmnret=0;
 476    uint8_t  BuildNrModeret=0;
 477    uint8_t  idx;
 478    uint8_t  plmnidx;
 479    uint8_t  plmnCnt=1;
 480    GNB_DU_Served_Cells_Item_t *srvCellItem;
 481    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 482    duServedCell->list.count = plmnCnt;
 483
 484    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
 485    if(duServedCell->list.array == NULLP)
 486    {
 487            return RFAILED;
 488    }
 489    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 490    {
 491       DU_ALLOC(duServedCell->list.array[plmnidx],\
 492              sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 493       if(duServedCell->list.array[plmnidx] == NULLP)
 494       {
 495                    return RFAILED;
 496       }
 497    }
 498    idx = 0;
 499    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 500    duServedCell->list.array[idx]->criticality = Criticality_reject;
 501    duServedCell->list.array[idx]->value.present = \
 502                 GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 503    srvCellItem = \
 504            &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 505    /*nRCGI*/
 506    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 507    if(BuildNrcgiret != ROK)
 508    {
 509            return RFAILED;
 510    }
 511       /*nRPCI*/
 512    srvCellItem->served_Cell_Information.nRPCI = \
 513                          duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 514
 515    /*fiveGS_TAC*/
 516    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 517    if(BuildFiveGSTacret != ROK)
 518    {
 519            return RFAILED;
 520    }
 521    /*Served PLMNs*/
 522    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 523    if(BuildServedPlmnret !=ROK)
 524    {
 525             return RFAILED;
 526    }
 527    /*nR Mode Info with FDD*/
 528    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 529    if(BuildNrModeret != ROK)
 530    {
 531            return RFAILED;
 532    }
 533    /*Measurement timing Config*/
 534    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 535       size = sizeof(uint8_t);
 536    DU_ALLOC(srvCellItem->served_Cell_Information.\
 537          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 538    if(srvCellItem->served_Cell_Information.\
 539          measurementTimingConfiguration.buf == NULLP)
 540    {
 541             return RFAILED;
 542    }
 543    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 544              duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 545
 546    /* GNB DU System Information */
 547    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 548                         sizeof(GNB_DU_System_Information_t));
 549    if(!srvCellItem->gNB_DU_System_Information)
 550    {
 551            return RFAILED;
 552    }
 553    /* MIB */
 554    srvCellItem->gNB_DU_System_Information->mIB_message.size =\
 555               strlen(( char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
 556    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 557               srvCellItem->gNB_DU_System_Information->mIB_message.size);
 558    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 559    {
 560            return RFAILED;
 561    }
 562    strcpy((char *)srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 563                         (char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
 564
 565     /* SIB1 */
 566    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 567               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 568
 569    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 570               srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 571    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 572    {
 573             return RFAILED;
 574    }
 575    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 576    {
 577          srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 578            duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 579    }
 580   return ROK;
 581 }
 582 /*******************************************************************
 583  *
 584  * @brief Builds RRC Version
 585  *
 586  * @details
 587  *
 588  *    Function : BuildRrcVer
 589  *
 590  *    Functionality: Building RRC Version
 591  *
 592  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 593  * @return ROK     - success
 594  *         RFAILED - failure
 595  *
 596  * ****************************************************************/
 597 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
 598 {
 599    uint8_t rrcExt;
 600    uint8_t rrcLatest;
 601    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
 602    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
 603    if(rrcVer->latest_RRC_Version.buf == NULLP)
 604    {
 605            return RFAILED;
 606    }
 607    rrcVer->latest_RRC_Version.buf[0] = 0;
 608    rrcVer->latest_RRC_Version.bits_unused = 5;
 609    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 610    if(rrcVer->iE_Extensions == NULLP)
 611    {
 612            return RFAILED;
 613    }
 614    rrcVer->iE_Extensions->list.count = 1;
 615    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
 616    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
 617    if(rrcVer->iE_Extensions->list.array == NULLP)
 618    {
 619            return RFAILED;
 620    }
 621    rrcExt = 0;
 622    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 623          sizeof(RRC_Version_ExtIEs_t));
 624    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 625    {
 626            return RFAILED;
 627    }
 628    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
 629                              ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 630    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
 631    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
 632               RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 633    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 634              .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 635    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 636         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 637          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 638    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 639           .Latest_RRC_Version_Enhanced.buf == NULLP)
 640    {
 641            return RFAILED;
 642    }
 643    rrcLatest = 0;
 644    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 645    Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
 646    rrcLatest++;
 647    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 648    Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
 649    rrcLatest++;
 650    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 651    Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
 652    return ROK;
 653 }
 654 /*******************************************************************
 655 *
 656 * @brief Sends F1 msg over SCTP
 657 *
 658 * @details
 659 *
 660 *    Function : SendF1APMsg
 661 *
 662 *    Functionality: Sends F1 msg over SCTP
 663 *
 664 * @params[in] Region region
 665 *             Pool pool
 666 * @return ROK     - success
 667 *         RFAILED - failure
 668 *
 669 * ****************************************************************/
 670 uint8_t SendF1APMsg(Region region, Pool pool)
 671 {
 672    Buffer *mBuf;
 673
 674    if(SGetMsg(region, pool, &mBuf) == ROK)
 675    {
 676       if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK)
 677       {
 678          SPrntMsg(mBuf, 0,0);
 679
 680          if(sctpSend(mBuf, F1_INTERFACE) != ROK)
 681          {
 682             DU_LOG("\nF1AP : SCTP Send failed");
 683             SPutMsg(mBuf);
 684             return RFAILED;
 685          }
 686       }
 687       else
 688       {
 689          DU_LOG("\nF1AP : SAddPstMsgMult failed");
 690          SPutMsg(mBuf);
 691          return RFAILED;
 692       }
 693       SPutMsg(mBuf);
 694    }
 695    else
 696    {
 697       DU_LOG("\nF1AP : Failed to allocate memory");
 698       return RFAILED;
 699    }
 700    return ROK;
 701 } /* SendF1APMsg */
 702
 703 /*******************************************************************
 704 *
 705 * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
 706 *
 707 * @details
 708 *
 709 *    Function :  FreeRrcVer
 710 *
 711 *    Functionality: deallocating the memory of function BuildRrcVer
 712 *
 713 * @params[in] RRC_Version_t *rrcVer
 714 *
 715 * @return void
 716 *
 717 *****************************************************************/
 718 void FreeRrcVer(RRC_Version_t *rrcVer)
 719 {
 720    if(rrcVer->latest_RRC_Version.buf != NULLP)
 721         {
 722            if(rrcVer->iE_Extensions != NULLP)
 723                 {
 724                    if(rrcVer->iE_Extensions->list.array != NULLP)
 725                         {
 726                            if(rrcVer->iE_Extensions->list.array[0] != NULLP)
 727                                 {
 728                                    if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
 729                                         != NULLP)
 730                                         {
 731                                            DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
 732                                                 .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 733                                                 array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 734                                         }
 735                                         DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
 736                                 }
 737                                 DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
 738                         }
 739                         DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 740                 }
 741                 DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
 742         }
 743 }
 744 /*******************************************************************
 745 *
 746 * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
 747 *
 748 * @details
 749 *
 750 *    Function :  FreeServedCellList
 751 *
 752 *    Functionality:  deallocating the memory of function BuildServedCellList
 753
 754 *
 755 * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
 756 *
 757 * @return void
 758 *
 759 * ****************************************************************/
 760 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
 761 {
 762    uint8_t   plmnCnt=1;
 763    uint8_t  servId=0;
 764         uint8_t sliceId=0;
 765         uint8_t  ieId=0;
 766         uint8_t   extensionCnt=1;
 767         uint8_t plmnidx=0;
 768    GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
 769    if(duServedCell->list.array!=NULLP)
 770    {
 771      if(duServedCell->list.array[0]!=NULLP)
 772           {
 773              if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
 774              {
 775                      if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
 776                           {
 777                              if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
 778                                   {
 779                                      if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
 780                                           {
 781                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
 782                                                   {
 783                                                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
 784                                                           {
 785                                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
 786                                                                   {
 787                                                                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
 788                                                                           {
 789                                                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
 790                                                                                   {
 791                                                                                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
 792                                                                                           {
 793                                                                                             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 794                                                                                                  extensionValue.choice.SliceSupportList.list.array!=NULLP)
 795                                                                                                  {
 796                                                                                                     if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 797                                                                                                          extensionValue.choice.SliceSupportList.list.array[sliceId]!= NULLP)
 798                                                                                                          {
 799                                                                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 800                                                                                                         extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.buf!=NULLP)
 801                                                                                                         {
 802                                                                                                            if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 803                                                                                                                 extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
 804                                                                                                                 {
 805                                                                                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
 806                                                                                                                         list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
 807                                                                                                                    {
 808                                                      if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
 809                                                                                                                                 {
 810                                                                                                                                    if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
 811                                                                                                                                         freqBandListNr.list.array!=NULLP)
 812                                                                                                                                         {
 813                                                                                                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
 814                                                                                                                                                  freqBandListNr.list.array[0]!=NULLP)
 815                                                                                                                                                  {
 816                                                                                                                                                     if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 817                                                                                                                                                          freqBandListNr.list.array)
 818                                                                                                                                                          {
 819                                                                                                                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 820                                                                                                                                                             freqBandListNr.list.array[0]!=NULLP)
 821                                                                                                                                                                  {
 822                                                                                                                                                                     if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
 823                                                                                                                                                                          {
 824                                                                                                                                                                             if(!srvCellItem->gNB_DU_System_Information)
 825                                                                                                                                                                                  {
 826                                                                                                                                                                                     if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
 827                                                                                                                                                                                          {
 828                                                                                                                                                                                                   if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
 829                                                                                                                                                                                                   {
 830                                                                                                                                                                                                      DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
 831                                                                                                                                                                                                       srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 832                                                                                                                                                                                                                          DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
 833                                                                                                                                                                                                                           srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 834                                                                                                                                                                                                   }
 835                                                                                                                                                                                              DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
 836                                                                                                                                                                                              srvCellItem->gNB_DU_System_Information->mIB_message.size);
 837                                                                                                                                                                                                                  DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
 838                                                                                                                                                                                                                  strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
 839                                                                                                                                                                                      }
 840                                                                                                                                                                                      DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
 841                                                                                                                                                                                   }
 842                                                                                                                                                                              DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
 843                                                                                                                                                                                   srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 844                                                                                                                                                                          }
 845                                                                                                                                                                     DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 846                                                                                                                                                                          freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
 847                                                                                                                                                                  }
 848                                                                                                                                                             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 849                                                                                                                                                                  freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
 850                                                                                                                                                         }
 851                                                                                                                                                    DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
 852                                                                                                                                                                   list.array[0],sizeof(FreqBandNrItem_t));
 853                                                                                                                                                 }
 854                                                                                                                                            DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
 855                                                                                                                                                           list.array,sizeof(FreqBandNrItem_t*));
 856                                                                                                                                         }
 857                                                                                                                                    DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
 858                                                                                                                                 }
 859                                                                                                                            DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 860                                                                                                                                 iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
 861                                                                                                                                           sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
 862                                                                                                                                          list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 863                                                                                                                                  }
 864                                                                                                                   DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 865                                                                                                                        iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 866                                                                                                                         list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 867                                                                                                                }
 868                                                                                                           DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 869                                                                                                                iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
 870                                                                                                                          sNSSAI.sST.buf,sizeof(uint8_t));
 871                                                                                                             }
 872                                                                                                                  DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 873                                            extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
 874                                                                                                     }
 875                                         DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 876                                                                                                           extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
 877                                      }
 878                                                                                             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 879                                                                                                  array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
 880                                                                                           }
 881                                                                                      DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 882                                                                                           array[servId]->iE_Extensions->list.array,\
 883                                                                                           extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
 884                                                                                   }
 885                                                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 886                                                                                   array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
 887                                                                           }
 888                                                                      DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 889                                                                           array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
 890                                                                           servedPLMNs.list.array[servId]->pLMN_Identity.size
 891                                                                           * sizeof(uint8_t));
 892                                                                   }
 893                                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
 894                                                                   sizeof(ServedPLMNs_Item_t *));
 895                                                           }
 896                                                      DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
 897                                                           sizeof(ServedPLMNs_Item_t *));
 898                                                   }
 899                                              DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
 900                                                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
 901                                           }
 902                                      DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
 903                                   }
 904                              DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
 905                                   srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
 906                                   sizeof(uint8_t));
 907                           }
 908                      DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
 909                           srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
 910                           sizeof(uint8_t));
 911                   }
 912              DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 913           }
 914      DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
 915   }
 916 }
 917 /*******************************************************************
 918  *
 919  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
 920  *
 921  * @details
 922  *
 923  *    Function :  FreeF1SetupReq
 924  *
 925  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
 926  *
 927  * @params[in] F1AP_PDU_t *f1apMsg
 928  *
 929  * @return void
 930  *
 931  * ****************************************************************/
 932 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
 933 {
 934     uint8_t idx =0;
 935          uint8_t idx1=1;
 936          F1SetupRequest_t           *f1SetupReq=NULLP;
 937
 938
 939     if(f1apMsg != NULLP)
 940     {
 941          if(f1apMsg->choice.initiatingMessage != NULLP)
 942          {
 943                              f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
 944               if(f1SetupReq->protocolIEs.list.array != NULLP)
 945                    {
 946                                        if(f1SetupReq->protocolIEs.list.array[idx1]!=NULLP)
 947                                                  {
 948                              if(f1SetupReq->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.buf !=  NULLP)
 949                              {
 950                                  idx1++;
 951                                  if(f1SetupReq->protocolIEs.list.array[idx1]->value.choice.GNB_DU_Name.buf != NULLP)
 952                                  {
 953                                       idx1=4;
 954                                                                                         if(ServedCellListreturn == ROK)
 955                                       {
 956                                           FreeRrcVer(&f1SetupReq->protocolIEs.list.array[idx1]->value.choice.RRC_Version);
 957                                       }
 958                                                                                         idx1--;
 959                                       FreeServedCellList(&f1SetupReq->protocolIEs.list.array[idx1]->value.choice.GNB_DU_Served_Cells_List);
 960                                       idx1--;
 961                                                                                         DU_FREE(f1SetupReq->protocolIEs.list.array[idx1]->value.choice.GNB_DU_Name.buf,
 962                                       strlen((char *)duCfgParam.duName));
 963                                  }
 964                                  idx1--;
 965                                  DU_FREE(f1SetupReq->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.buf,\
 966                                  f1SetupReq->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.size);
 967                                                            }
 968                         }
 969                         for(idx=0; idx<f1SetupReq->protocolIEs.list.count; idx++)
 970                         {
 971                              if(f1SetupReq->protocolIEs.list.array[idx]!=NULLP)
 972                              {
 973                                   DU_FREE(f1SetupReq->protocolIEs.list.array[idx],sizeof(F1SetupRequestIEs_t));
 974                               }
 975                                          }
 976                         DU_FREE(f1SetupReq->protocolIEs.list.array,\
 977                              f1SetupReq->protocolIEs.list.size);
 978                         }
 979                         DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 980                    }
 981                    DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 982         }
 983
 984 }
 985 /*******************************************************************
 986  *
 987  * @brief Builds and Send the F1SetupRequest
 988  *
 989  * @details
 990  *
 991  *    Function : BuildAndSendF1SetupReq
 992  *
 993  * Functionality:Fills the F1SetupRequest
 994  *
 995  * @return ROK     - success
 996  *         RFAILED - failure
 997  *
 998  ******************************************************************/
 999 uint8_t BuildAndSendF1SetupReq()
1000 {
1001    uint8_t   idx=0;
1002         uint8_t   idx2=0;
1003         uint8_t   i=0;
1004    uint8_t   elementCnt=0;
1005    F1AP_PDU_t                 *f1apMsg = NULLP;
1006    F1SetupRequest_t           *f1SetupReq=NULLP;
1007    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1008    RRC_Version_t              *rrcVer=NULLP;
1009    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1010         uint8_t  ret= RFAILED;
1011         uint8_t  BuildRrcVerreturn=0;
1012
1013    DU_LOG("\nF1AP : Building F1 Setup Request\n");
1014    do
1015    {
1016       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1017       if(f1apMsg == NULLP)
1018       {
1019          break;
1020       }
1021       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1022       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1023       if(f1apMsg->choice.initiatingMessage == NULLP)
1024       {
1025          break;
1026       }
1027       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1028       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1029       f1apMsg->choice.initiatingMessage->value.present = \
1030                                     InitiatingMessage__value_PR_F1SetupRequest;
1031
1032       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1033
1034       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1035
1036       f1SetupReq->protocolIEs.list.count = elementCnt;
1037       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1038
1039       /* Initialize the F1Setup members */
1040       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1041       if(f1SetupReq->protocolIEs.list.array == NULLP)
1042       {
1043          break;
1044       }
1045       for(idx=0; idx<elementCnt; idx++)
1046       {
1047          DU_ALLOC(f1SetupReq->protocolIEs.list.array[idx],\
1048             sizeof(F1SetupRequestIEs_t));
1049          if(f1SetupReq->protocolIEs.list.array[idx] == NULLP)
1050          {
1051             break;
1052          }
1053       }
1054       idx2 = 0;
1055
1056       /*TransactionID*/
1057       f1SetupReq->protocolIEs.list.array[idx2]->id = ProtocolIE_ID_id_TransactionID;
1058       f1SetupReq->protocolIEs.list.array[idx2]->criticality = Criticality_reject;
1059       f1SetupReq->protocolIEs.list.array[idx2]->value.present =\
1060                                     F1SetupRequestIEs__value_PR_TransactionID;
1061       f1SetupReq->protocolIEs.list.array[idx2]->value.choice.TransactionID = \
1062                                                                    TRANS_ID;
1063
1064       /*DU ID*/
1065       idx2++;
1066       f1SetupReq->protocolIEs.list.array[idx2]->id = ProtocolIE_ID_id_gNB_DU_ID;
1067       f1SetupReq->protocolIEs.list.array[idx2]->criticality = Criticality_reject;
1068       f1SetupReq->protocolIEs.list.array[idx2]->value.present = \
1069          F1SetupRequestIEs__value_PR_GNB_DU_ID;
1070       f1SetupReq->protocolIEs.list.array[idx2]->value.choice.GNB_DU_ID.size =\
1071                                                                     sizeof(uint8_t);
1072
1073       DU_ALLOC(f1SetupReq->protocolIEs.list.array[idx2]->value.choice.GNB_DU_ID.buf,\
1074            f1SetupReq->protocolIEs.list.array[idx2]->value.choice.GNB_DU_ID.size);
1075       if(f1SetupReq->protocolIEs.list.array[idx2]->value.choice.GNB_DU_ID.buf == \
1076          NULLP)
1077       {
1078          break;
1079       }
1080
1081       f1SetupReq->protocolIEs.list.array[idx2]->value.choice.GNB_DU_ID.buf[0] =\
1082                                                              duCfgParam.duId;
1083
1084       /*DU Name*/
1085       if(duCfgParam.duName != NULL)
1086       {
1087          idx2++;
1088          f1SetupReq->protocolIEs.list.array[idx2]->id = ProtocolIE_ID_id_gNB_DU_Name ;
1089          f1SetupReq->protocolIEs.list.array[idx2]->criticality = Criticality_ignore;
1090          f1SetupReq->protocolIEs.list.array[idx2]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1091          f1SetupReq->protocolIEs.list.array[idx2]->value.choice.GNB_DU_Name.size =\
1092                                                         strlen((char *)duCfgParam.duName);
1093          DU_ALLOC(f1SetupReq->protocolIEs.list.array[idx2]->value.choice.\
1094             GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1095          if(f1SetupReq->protocolIEs.list.array[idx2]->value.choice.GNB_DU_Name.\
1096             buf == NULLP)
1097          {
1098             break;
1099          }
1100          strcpy((char*)f1SetupReq->protocolIEs.list.array[idx2]->value.\
1101             choice.GNB_DU_Name.buf,
1102          (char*)&duCfgParam.duName);
1103
1104       }
1105
1106        /*Served Cell list */
1107       idx2++;
1108       f1SetupReq->protocolIEs.list.array[idx2]->id = \
1109                                  ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1110       f1SetupReq->protocolIEs.list.array[idx2]->criticality = Criticality_reject;
1111       f1SetupReq->protocolIEs.list.array[idx2]->value.present = \
1112                             F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1113       duServedCell = &f1SetupReq->protocolIEs.list.\
1114                   array[idx2]->value.choice.GNB_DU_Served_Cells_List;
1115       ServedCellListreturn = BuildServedCellList(duServedCell);
1116       if(ServedCellListreturn != ROK)
1117       {
1118          break;
1119       }
1120       /*RRC Version*/
1121       idx2++;
1122       f1SetupReq->protocolIEs.list.array[idx2]->id = \
1123                                   ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1124       f1SetupReq->protocolIEs.list.array[idx2]->criticality = Criticality_reject;
1125       f1SetupReq->protocolIEs.list.array[idx2]->value.present = \
1126                                     F1SetupRequestIEs__value_PR_RRC_Version;
1127       rrcVer = &f1SetupReq->protocolIEs.list.array[idx2]->value.choice.RRC_Version;
1128       BuildRrcVerreturn = BuildRrcVer(rrcVer);
1129       if(BuildRrcVerreturn != ROK)
1130       {
1131                         break;
1132       }
1133       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1134
1135       /* Encode the F1SetupRequest type as APER */
1136       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
1137       encBufSize = 0;
1138       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1139          encBuf);
1140
1141       /* Encode results */
1142       if(encRetVal.encoded == ENCODE_FAIL)
1143       {
1144            DU_LOG("\nF1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1145                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1146                           break;
1147       }
1148       else
1149       {
1150            DU_LOG("\nF1AP : Created APER encoded buffer for F1SetupRequest\n");
1151            for(i=0; i< encBufSize; i++)
1152            {
1153                    printf("%x",encBuf[i]);
1154            }
1155       }
1156
1157       /* Sending msg */
1158       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1159        {
1160            DU_LOG("\nF1AP : Sending F1 Setup request failed");
1161                           break;
1162       }
1163
1164                 ret=ROK;
1165       break;
1166    }while(1);
1167
1168         FreeF1SetupReq(f1apMsg);
1169
1170         return ret;
1171 }/* End of BuildAndSendF1SetupReq */
1172
1173 /*******************************************************************
1174  *
1175  * @brief Builds and sends the DUConfigUpdate
1176  *
1177  * @details
1178  *
1179  *    Function : BuildAndSendDUConfigUpdate
1180  *
1181  *    Functionality: Constructs the DU Update message and sends
1182  *                   it to the CU through SCTP.
1183  *
1184  * @params[in] void **buf,Buffer to which encoded pattern is written into
1185  * @params[in] int *size,size of buffer
1186  *
1187  * @return ROK     - success
1188  *         RFAILED - failure
1189  *
1190  * ****************************************************************/
1191 uint8_t BuildAndSendDUConfigUpdate()
1192 {
1193    uint8_t idx;
1194         uint8_t idy;
1195         uint8_t idx1;
1196         uint8_t idy1;
1197         uint8_t idy2;
1198    uint8_t elementCnt;
1199         uint8_t modifyCnt;
1200         uint8_t servPlmnCnt;
1201         uint8_t extensionCnt;
1202    asn_enc_rval_t encRetVal;      /* Encoder return value */
1203    F1AP_PDU_t *f1apDuCfg = NULL;
1204    GNBDUConfigurationUpdate_t *duCfgUpdate;
1205    Served_Cells_To_Modify_List_t  *cellsToModify;
1206    Served_Cells_To_Modify_Item_t *modifyItem;
1207    uint8_t ret= RFAILED;
1208    uint8_t i;
1209
1210         while(1)
1211         {
1212             DU_LOG("\nF1AP : Building DU config update\n");
1213                  /* Allocate the memory for F1DuCfg */
1214             DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
1215                  if(f1apDuCfg == NULLP)
1216                  {
1217                    DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
1218                    break;
1219                  }
1220
1221                  f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
1222        DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1223        if(f1apDuCfg->choice.initiatingMessage == NULLP)
1224                  {
1225                     DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
1226                          break;
1227                  }
1228
1229                  f1apDuCfg->choice.initiatingMessage->procedureCode = \
1230                                  ProcedureCode_id_gNBDUConfigurationUpdate;
1231                  f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
1232                  f1apDuCfg->choice.initiatingMessage->value.present = \
1233                                  InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
1234             duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
1235                                     choice.GNBDUConfigurationUpdate;
1236                  elementCnt = 3;
1237                  duCfgUpdate->protocolIEs.list.count = elementCnt;
1238                  duCfgUpdate->protocolIEs.list.size = \
1239                                  elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
1240
1241            /* Initialize the F1Setup members */
1242                  DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1243                  if(duCfgUpdate->protocolIEs.list.array == NULLP)
1244                  {
1245                    DU_LOG("F1AP : Memory allocation for F1RequestIEs failed");
1246                         break;
1247                  }
1248                  for(idx=0;idx<elementCnt;idx++)
1249                  {
1250                     DU_ALLOC(duCfgUpdate->protocolIEs.list.array[idx],sizeof(GNBDUConfigurationUpdateIEs_t));
1251                           if(duCfgUpdate->protocolIEs.list.array[idx] == NULLP)
1252                           {
1253                                   break;
1254                           }
1255                  }
1256
1257                  /*TransactionID*/
1258                  idx1 = 0;
1259                  duCfgUpdate->protocolIEs.list.array[idx1]->id=ProtocolIE_ID_id_TransactionID;
1260                  duCfgUpdate->protocolIEs.list.array[idx1]->criticality= Criticality_reject;
1261                  duCfgUpdate->protocolIEs.list.array[idx1]->value.present = \
1262                                              GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
1263                  duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.TransactionID = \
1264                         TRANS_ID;
1265
1266        /*Served Cell to Modify */
1267                  idx1++;
1268        duCfgUpdate->protocolIEs.list.array[idx1]->id = \
1269                                             ProtocolIE_ID_id_Served_Cells_To_Modify_List;
1270        duCfgUpdate->protocolIEs.list.array[idx1]->criticality =Criticality_reject;
1271        duCfgUpdate->protocolIEs.list.array[idx1]->value.present = \
1272                                                   GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
1273             cellsToModify = &duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.\
1274                              Served_Cells_To_Modify_List;
1275        modifyCnt = 1;
1276                  cellsToModify->list.count = modifyCnt;
1277                  cellsToModify->list.size = \
1278                                  modifyCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
1279                  DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
1280                  if(cellsToModify->list.array == NULLP)
1281                  {
1282                break;
1283                  }
1284                  for(idy=0; idy<modifyCnt ;idy++)
1285                  {
1286                     DU_ALLOC(cellsToModify->list.array[idy],sizeof(\
1287                          Served_Cells_To_Modify_ItemIEs_t));
1288                          if(cellsToModify->list.array[idy] == NULLP)
1289                          {
1290                                  break;
1291                          }
1292                  }
1293             cellsToModify->list.array[0]->id = \
1294                                    ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
1295                  cellsToModify->list.array[0]->criticality = Criticality_reject;
1296             cellsToModify->list.array[0]->value.present =\
1297                        Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
1298             modifyItem=&cellsToModify->list.array[0]->value.choice.\
1299                    Served_Cells_To_Modify_Item;
1300
1301        /*pLMN_Identity*/
1302                  modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
1303                  DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
1304                  if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
1305                  {
1306                     break;
1307                  }
1308        buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1309                               &modifyItem->oldNRCGI.pLMN_Identity);
1310
1311             /*nRCellIdentity*/
1312                  modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
1313                  DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1314                      modifyItem->oldNRCGI.nRCellIdentity.size);
1315                  if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
1316                  {
1317           break;
1318                  }
1319        for (int tmp = 0;tmp < modifyItem->oldNRCGI.nRCellIdentity.size-1;tmp++)
1320                  {
1321            modifyItem->oldNRCGI.nRCellIdentity.buf[tmp] = 0;
1322                  }
1323                  modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
1324                  modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
1325                  /*pLMN_Identity*/
1326                  /*nRCGI*/
1327                  modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
1328        DU_ALLOC(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1329                      modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1330                  if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf == NULLP)
1331        {
1332                          break;
1333                  }
1334        buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1335                      &modifyItem->served_Cell_Information.nRCGI.pLMN_Identity);
1336                  modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
1337                  DU_ALLOC(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1338                     modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1339                  if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf == NULLP)
1340                  {
1341                         break;
1342                  }
1343        for (int tmp = 0 ; tmp < modifyItem->served_Cell_Information.\
1344                      nRCGI.nRCellIdentity.size-1 ; tmp++)
1345             {
1346                     modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf[tmp] = 0;
1347                  }
1348             modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf[4] = 16;
1349        modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.bits_unused =4;
1350        /*nRPCI*/
1351             modifyItem->served_Cell_Information.nRPCI = \
1352                                duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1353        /*servedPLMNs*/
1354             servPlmnCnt = 1;
1355             modifyItem->served_Cell_Information.servedPLMNs.list.count = servPlmnCnt;
1356        modifyItem->served_Cell_Information.servedPLMNs.list.size = \
1357                      servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1358                  DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1359                        modifyItem->served_Cell_Information.servedPLMNs.list.size);
1360             if(modifyItem->served_Cell_Information.servedPLMNs.list.array == NULLP)
1361                  {
1362                         break;
1363                  }
1364        for(idy1=0;idy1<servPlmnCnt;idy1++)
1365                  {
1366                      DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy1],\
1367                            sizeof(ServedPLMNs_Item_t));
1368                                 if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy1]== NULLP)
1369                                 {
1370                                          break;
1371                                 }
1372                  }
1373                  modifyItem->served_Cell_Information.servedPLMNs.list.\
1374                      array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
1375                  DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
1376                            array[0]->pLMN_Identity.buf,modifyItem->served_Cell_Information.servedPLMNs.list.\
1377                                           array[0]->pLMN_Identity.size);
1378                  if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1379                          array[0]->pLMN_Identity.buf == NULLP)
1380                  {
1381                          break;
1382                  }
1383        buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
1384                      &modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->pLMN_Identity);
1385        DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
1386                        array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1387                  if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1388                        array[0]->iE_Extensions == NULLP)
1389                  {
1390                          break;
1391                  }
1392        extensionCnt=1;
1393                  modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1394                        iE_Extensions->list.count = extensionCnt;
1395                  modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1396                      iE_Extensions->list.size = extensionCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1397                  DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
1398                       array[0]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1399                                  iE_Extensions->list.size);
1400                  if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1401                         array[0]->iE_Extensions->list.array == NULLP)
1402                  {
1403                    break;
1404                  }
1405        for(idy2=0;idy2<extensionCnt;idy2++)
1406                  {
1407                     DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
1408                            array[0]->iE_Extensions->list.array[idy2],\
1409                                 sizeof(ServedPLMNs_ItemExtIEs_t));
1410                          if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1411                                    array[0]->iE_Extensions->list.array[idy2] == NULLP)
1412                          {
1413                                   break;
1414                          }
1415                  }
1416                  modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1417                     iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
1418        modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1419               iE_Extensions->list.array[0]->criticality = Criticality_ignore;
1420             modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1421           iE_Extensions->list.array[0]->extensionValue.present = \
1422                          ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1423             modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1424                    iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1425                         list.count = 1;
1426                  modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1427                     iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1428                          list.size = sizeof(SliceSupportItem_t *);
1429                  DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1430                     iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1431           list.array,modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1432                          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
1433             if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1434                     iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1435                           list.array == NULLP)
1436                  {
1437                         break;
1438                  }
1439
1440                  DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1441                    iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1442                         list.array[0],sizeof( SliceSupportItem_t));
1443                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1444                     iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1445                           list.array[0] == NULLP)
1446                  {
1447                    break;
1448                  }
1449                  modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1450                    iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1451                         list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
1452                  DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1453                    iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1454                         list.array[0]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1455                         iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
1456             if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1457                    iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1458                         list.array[0]->sNSSAI.sST.buf == NULLP)
1459                  {
1460                          break;
1461                  }
1462        modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1463                     iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1464                          list.array[0]->sNSSAI.sST.buf[0] = 3;
1465             DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1466                   iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1467                    list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1468                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1469                    iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1470                         list.array[0]->sNSSAI.sD == NULLP)
1471             {
1472                          break;
1473                  }
1474                  modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1475                    iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1476                         list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
1477        DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1478                    iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1479                    list.array[0]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1480                         iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1481                         list.array[0]->sNSSAI.sD->size);
1482        if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1483                    iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1484                         list.array[0]->sNSSAI.sD->buf == NULLP)
1485                  {
1486                          break;
1487                  }
1488        modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1489                   iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1490                   list.array[0]->sNSSAI.sD->buf[0] = 3;
1491                  modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1492                     iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1493                          list.array[0]->sNSSAI.sD->buf[1] = 6;
1494                  modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1495                     iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1496                          list.array[0]->sNSSAI.sD->buf[2] = 9;
1497
1498                  /*nR Mode Info with FDD*/
1499        modifyItem->served_Cell_Information.nR_Mode_Info.present = \
1500                                              NR_Mode_Info_PR_fDD;
1501                  DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
1502                                     sizeof(FDD_Info_t));
1503                  if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD == NULLP)
1504                  {
1505                          break;
1506                  }
1507        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1508                      uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1509                            f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1510                  modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1511                      uL_NRFreqInfo.freqBandListNr.list.count = 1;
1512                  modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1513                      uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1514                  DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1515                      fDD->uL_NRFreqInfo.freqBandListNr.list.\
1516                           array, modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1517                            uL_NRFreqInfo.freqBandListNr.list.size);
1518        if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1519                             fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1520                  {
1521                          break;
1522                  }
1523                  DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1524                        uL_NRFreqInfo.freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1525                  if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->
1526                       uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1527                  {
1528           break;
1529                  }
1530        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1531          freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1532          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
1533          freqBand[0].nrFreqBand;
1534        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1535           freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1536        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1537           nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
1538           dlNrFreqInfo.nrArfcn;
1539        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1540           freqBandListNr.list.count = 1;
1541        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1542           freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
1543        DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1544          dL_NRFreqInfo.freqBandListNr.list.array,modifyItem->served_Cell_Information.nR_Mode_Info.\
1545                         choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1546        if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1547          dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1548        {
1549                         break;
1550        }
1551             DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1552          dL_NRFreqInfo.freqBandListNr.list.array[0],\
1553          sizeof(FreqBandNrItem_t));
1554        if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1555          dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1556        {
1557                      break;
1558        }
1559        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1560         freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1561         duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
1562         freqBand[0].nrFreqBand;
1563        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1564         freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1565
1566        /*Transmission Bandwidth*/
1567        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1568         uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1569         f1Mode.mode.fdd.ulTxBw.nrScs;
1570        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1571         uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1572         f1Mode.mode.fdd.ulTxBw.nrb;
1573        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1574         dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1575         f1Mode.mode.fdd.dlTxBw.nrScs;
1576        modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1577         dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1578         f1Mode.mode.fdd.dlTxBw.nrb;
1579        /*Measurement timing Config*/
1580        modifyItem->served_Cell_Information.measurementTimingConfiguration.size = \
1581                                                               sizeof(uint8_t);
1582        DU_ALLOC(modifyItem->served_Cell_Information.measurementTimingConfiguration.\
1583          buf,modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1584        if(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf == NULLP)
1585        {
1586                         break;
1587        }
1588        modifyItem->served_Cell_Information.measurementTimingConfiguration.\
1589           buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1590
1591        // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
1592        /*GNB DU ID */
1593        idx1++;
1594        duCfgUpdate->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_ID;
1595        duCfgUpdate->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
1596        duCfgUpdate->protocolIEs.list.array[idx1]->value.present = \
1597                              GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
1598        duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.size = \
1599                                                              sizeof(uint8_t);
1600        DU_ALLOC(duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.buf,\
1601           duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.size);
1602        if(duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.buf == NULLP)
1603        {
1604                          break;
1605        }
1606        duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.buf[0] = \
1607                                                               duCfgParam.duId;
1608
1609        xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
1610
1611        /* Encode the DU Config Update type as APER */
1612        cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
1613        encBufSize = 0;
1614        encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
1615
1616        /* Checking encode results */
1617        if(encRetVal.encoded == ENCODE_FAIL)
1618        {
1619             DU_LOG("F1AP : Could not encode DUConfigUpdate structure (at %s)\n",encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1620                                 break;
1621                  }
1622        else
1623        {
1624            DU_LOG("\nF1AP : Created APER encoded buffer for DUConfigUpdate\n");
1625            for(i=0; i< encBufSize; i++)
1626           {
1627               printf("%x",encBuf[i]);
1628           }
1629        }
1630        /* Sending msg */
1631        if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1632        {
1633           DU_LOG("\nF1AP : Sending GND-DU Config Update failed");
1634                          break;
1635        }
1636
1637                  ret = ROK;
1638                  break;
1639          }
1640          FreeDUConfigUpdate(f1apDuCfg);
1641
1642          return ret;
1643 }
1644  /*******************************************************************
1645  *
1646  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1647  *
1648  * @details
1649  *
1650  *    Function : FreeDUConfigUpdate
1651  *
1652  *    Functionality: Deallocating memory of variables allocated in
1653  *                    BuildAndSendDUConfigUpdate function
1654  *
1655  * @params[in]  F1AP_PDU_t *f1apDuCfg
1656  *
1657  * @return ROK     - void
1658  *
1659  * ****************************************************************/
1660 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1661 {
1662    uint8_t  i;
1663         uint8_t  idx;
1664    GNBDUConfigurationUpdate_t *duCfgUpdate;
1665    Served_Cells_To_Modify_List_t  *cellsToModify;
1666    Served_Cells_To_Modify_Item_t *modifyItem;
1667    idx=0;
1668    i=1;
1669    if(f1apDuCfg != NULLP)
1670         {
1671             if(f1apDuCfg->choice.initiatingMessage != NULLP)
1672                  {
1673                      duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1674                           value.choice.GNBDUConfigurationUpdate;
1675                      if(duCfgUpdate->protocolIEs.list.array != NULLP)
1676                           {
1677                                     if(duCfgUpdate->protocolIEs.list.array[i] != NULLP)
1678                                          {
1679                                               cellsToModify = &duCfgUpdate->protocolIEs.list.array[i]->\
1680                                                         value.choice.Served_Cells_To_Modify_List;
1681                                               if(cellsToModify->list.array != NULLP)
1682                                               {
1683                                                            if(cellsToModify->list.array[idx] != NULLP)
1684                                                                 {
1685                                                                          modifyItem=&cellsToModify->list.array[idx]->value.choice.\
1686                                                                          Served_Cells_To_Modify_Item;
1687                                                                          if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
1688                             {
1689                                                                             if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
1690                                                                             {
1691                                                                                       if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
1692                                                                                            {
1693                                                                                                      if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
1694                                                                                                      != NULLP)
1695                                                                                                           {
1696                                                                                                               if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
1697                                                                                                                         != NULLP)
1698                                                                                                                          {
1699                                                                                                                              if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[idx])
1700                                                                                                                                   {
1701                                                                                                                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1702                                                                                                                                             array[idx]->pLMN_Identity.buf != NULLP)
1703                                                        {
1704                                                            if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1705                                                                                                                                                             array[idx]->iE_Extensions!= NULLP)
1706                                                                                                                                                                  {
1707                                                                                                                                                                      if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1708                                                                  array[idx]->iE_Extensions->list.array != NULLP)
1709                                                                                                                                                                           {
1710                                                                                                                                                                                            if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1711                                                                                                                                                                                                 array[idx]->iE_Extensions->list.array[idx])
1712                                                                                                                                                                                                 {
1713                                                                                                                                                                                                    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1714                                                                                                                                                                                                    iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1715                                                                                                                                                                                                    list.array !=NULLP)
1716                                                                                                                                                                                                    {
1717                                                                                                                                                                                                       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1718                                                                                                                                                                                                            iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1719                                                                                                                                                                                                            list.array[idx]!=NULLP)
1720                                                                                                                                                                                                            {
1721                                                                                                                                                                                                               if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1722                                                                                                                                                                                                                    iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1723                                                                                                                                                                                                                    list.array[idx]->sNSSAI.sST.buf!=NULLP)
1724                                                                                                                                                                                                                    {
1725                                                                                                                                                                                                                       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1726                                                                                                                                                                                                                            iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1727                                                                                                                                                                                                                            list.array[idx]->sNSSAI.sD != NULLP)
1728                                                                                                                                                                                                                            {
1729                                                                                                                                                                                                                                if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1730                                                                                                                                                                                                                                          iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1731                                                                                                                                                                                                                                           list.array[idx]->sNSSAI.sD->buf!=NULLP)
1732                                                                                                                                                                                                                                          {
1733                                                                                                                                                                                                                                              if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
1734                                                                                                                                                                                                                                                   !=NULLP)
1735                                                                                                                                                                                                                                                   {
1736                                                                                                                                                                                                                                                      if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1737                                                                                                                                                                                                                                                           fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
1738                                                                                                                                                                                                                                                      {
1739                                                                                                                                                                                                                                                               if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1740                                                                                                                                                                                                                                                                         fDD->uL_NRFreqInfo.freqBandListNr.list.array[idx]!=NULLP)
1741                                                                                                                                                                                                                                                                         {
1742                                                                                                                                                                                                                                                                             if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1743                                                                                                                                                                                                                                                                                  fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
1744                                                                                                                                                                                                                                                                             {
1745                                                                                                                                                                                                                                                                                     if(modifyItem->served_Cell_Information.nR_Mode_Info.\
1746                                                                                                                                                                                                                                                                                          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1747                                                                                                                                                                                                                                                                                          array[idx]!= NULLP)
1748                                                                                                                                                                                                                                                                                          {
1749                                                                                                                                                                                                                                                                                             if(modifyItem->served_Cell_Information.\
1750                                                                                                                                                                                                                                                                                                  measurementTimingConfiguration.buf !=NULLP)
1751                                                                                                                                                                                                                                                                                                  {
1752                                                                                                                                                                                                                                                                                                    idx=2;
1753                                                                                                                                                                                                                                                                                                    if(duCfgUpdate->protocolIEs.list.array[idx]->value.\
1754                                                                                                                                                                                                                                                                                                         choice.GNB_DU_ID.buf!=NULLP)
1755                                                                                                                {
1756                                                                                                                                                                                                                                                                                                             DU_FREE(duCfgUpdate->protocolIEs.list.\
1757                                                                                                                                                                                                                                                                                                                  array[idx]->value.choice.GNB_DU_ID.buf,\
1758                                                                                                                                                                                                                                                                                                                  duCfgUpdate->protocolIEs.list.array[idx]->\
1759                                                                                                                                                                                                                                                                                                                  value.choice.GNB_DU_ID.size);
1760                                                                                                                                                                                                                                                                                                         }
1761                                                                                                                                                                                                                                                                                                         idx=0;
1762                                                                                                                                                                                                                                                                                                    DU_FREE(modifyItem->served_Cell_Information.\
1763                                                                                                                                                                                                                                                                                                         measurementTimingConfiguration.\
1764                                                                                                                                                                                                                                                                                                         buf,modifyItem->served_Cell_Information.\
1765                                                                                                                                                                                                                                                                                                         measurementTimingConfiguration.size);
1766                                                                                                                                                                                                                                                                                                  }
1767                                                                                                                                                                                                                                                                                             DU_FREE(modifyItem->served_Cell_Information.\
1768                                                                                                                                                                                                                                                                                                 nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.\
1769                                                                                                                                                                                                                                                                                            list.array[idx],sizeof(FreqBandNrItem_t));
1770                                                                                                                                                                                                                                                                                          }
1771                                                                                                                                                                                                                                                                                          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
1772                                                                                                                                                                                                                                                                                          .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1773                                                                                                                                                                                                                                                                                          modifyItem->served_Cell_Information.nR_Mode_Info.\
1774                                                                                                                                                                                                                                                                                          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1775                                                                                                                                                                                                                                                                                  }
1776                                                                                                                                                                                                                                                                                  DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1777                                                                                                                                                                                                                                                                                  choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1778                                                                                                                                                                                                                                                                                  array[idx],sizeof(FreqBandNrItem_t));
1779                                                                                                                                                                                                                                                                         }
1780                                                                                                                                                                                                                                                               DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1781                                                                                                                                                                                                                                                                         choice.\
1782                                                                                                                                                                                                                                                                    fDD->uL_NRFreqInfo.freqBandListNr.list.\
1783                                                                                                                                                                                                                                                                    array,modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1784                                                                                                                                                                                                                                                                    fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1785                                                                                                                                                                                                                                                            }
1786                                                                                                                                                                                                                                                       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1787                                                                                                                                                                                                                                                            fDD,sizeof(FDD_Info_t));
1788                                                                                                                                                                                                                                                    }
1789                                                                                                                                                                                                                                               DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1790                                                                                                                                                                                                                                                         array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1791                                                                                                                                                                                                                                                         SliceSupportList.\
1792                                                                                                                                                                                                                                                    list.array[idx]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.\
1793                                                                                                                                                                                                                                                    servedPLMNs.list.array[idx]->iE_Extensions->list.array[idx]->\
1794                                                                                                                                                                                                                                                    extensionValue.choice.SliceSupportList.list.array[idx]->\
1795                                                                                                                                                                                                                                                         sNSSAI.sD->size);
1796
1797                                                                                                                                                                                                                                            }
1798                                                                                                                                                                                                                                  DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1799                                                                                                                                                                                                                                                 array[idx]->\
1800                                                                                                                                                                                                                                            iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1801                                                                                                                                                                                                                                            list.array[idx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1802                                                                                                                                                                                                                              }
1803                                                                                                                                                                                                                         DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1804                                                                                                                                                                                                                              iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1805                                                                                                                                                                                                                              list.array[idx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
1806                                                                                                                                                                                                                                   servedPLMNs.\
1807                                                                                                                                                                                                                              list.array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1808                                                                                                                                                                                                                              SliceSupportList.list.array[idx]->sNSSAI.sST.size);
1809                                                                                                                                                                                                                     }
1810                                                                                                                                                                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1811                                                                                                                                                                                                                     iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1812                                                                                                                                                                                                                     list.array[idx],sizeof(SliceSupportItem_t));
1813                                                                                                                                                                                                       }
1814                                                                                                                                                                                                       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1815                                                                                                                                                                                                       iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1816                                                                                                                                                                                                       list.array,\
1817                                                                                                                                                                                                       modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1818                                                                                                                                                                                                       iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.list.size);
1819                                                                                                                                                                                                  }
1820                                                                                                                                                                                         }
1821                                                                                                                                                                                         for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
1822                                                                                                                                                                                         array[idx]->iE_Extensions->list.count;i++)
1823                                                                                                                                                                                         {
1824                                                                                                                                                                                                     DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1825                                                                                                                                                                                                          array[idx]->iE_Extensions->list.array[i],\
1826                                                                                                                                                                                                          sizeof(ServedPLMNs_ItemExtIEs_t ));
1827                                                                                                                                                                                         }
1828                                                                                                                                                                               DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1829                                                                                                                                                                                    array[idx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.
1830                                                                                                                                                                                         list.array[idx]->iE_Extensions->list.size);
1831                                                                                                                                                                           }
1832                                                                                                                                                                      DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1833                                                                                                                                                                             array[idx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1834                                                                                                                                                                  }
1835                                                                                                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1836                                                                                                                                                     array[idx]->pLMN_Identity.buf,
1837                                                                                                                                                          modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->pLMN_Identity.size);
1838                                                                                                                                                  }
1839                                                     }
1840                                                     for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1841                                                                                                                                          {
1842                                                                                                                                                     if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
1843                                                                                                                                                          != NULLP)
1844                                                                                                                                                     {
1845                                                                                                                                                              DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
1846                                                                                                                                                              sizeof(ServedPLMNs_Item_t));
1847                                                                                                                                                          }
1848                                                                                                                                          }
1849                                                                                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1850                                                                                                                                     modifyItem->served_Cell_Information.servedPLMNs.list.size);
1851                                                                                                                           }
1852                                                                                                                 DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1853                                                                                                                           modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1854                                                                                                           }
1855                                                                                                     DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1856                                                                                                           modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1857                                                                                                 }
1858                                                                                       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1859                                                                                              modifyItem->oldNRCGI.nRCellIdentity.size);
1860                                  }
1861                                                                               DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
1862                                                                                    modifyItem->oldNRCGI.pLMN_Identity.size);
1863                                                                       }
1864                           }
1865                                                                   for(i=0; i<cellsToModify->list.count ;i++)
1866                                                                   {
1867                                                                             if(cellsToModify->list.array[i] != NULLP)
1868                                                                                  {
1869                                                                                     DU_FREE(cellsToModify->list.array[i],\
1870                                                                                     sizeof(Served_Cells_To_Modify_ItemIEs_t));
1871                                                                                  }
1872                                                                   }
1873                                                         DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1874                                                      }
1875                                                  }
1876                                             for(i=0;i<duCfgUpdate->protocolIEs.list.count;i++)
1877                                                  {
1878                                                       if(duCfgUpdate->protocolIEs.list.array[i] !=NULLP)
1879                                                                 {
1880                                                      DU_FREE(duCfgUpdate->protocolIEs.list.array[i],\
1881                                                                sizeof(GNBDUConfigurationUpdateIEs_t));
1882                                                                 }
1883                                                  }
1884                    DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1885                             }
1886                             DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1887                   }
1888                   DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1889         }
1890 }
1891  /*******************************************************************
1892  *
1893  * @brief free the ULRRCMessageTransfer
1894  *
1895  * @details
1896  *
1897  *    Function : FreeULRRCMessageTransfer
1898  *
1899  *    Functionality: Deallocating the memory of variable allocated in
1900  *                      FreeULRRCMessageTransfer
1901  *
1902  * @params[in]
1903  *
1904  * @return ROK     - void
1905  *
1906  ******************************************************************/
1907 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
1908 {
1909      uint8_t idx1;
1910      ULRRCMessageTransfer_t  *ulRRCMsg;
1911
1912      if(f1apMsg != NULLP)
1913      {
1914          if(f1apMsg->choice.initiatingMessage != NULLP)
1915          {
1916              ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
1917                                  if(ulRRCMsg->protocolIEs.list.array != NULLP)
1918              {
1919                  for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
1920                  {
1921                      if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
1922                      {
1923                          DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
1924                      }
1925                  }
1926                  DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
1927              }
1928              DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1929          }
1930          DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1931       }
1932 }
1933 /*******************************************************************
1934  *
1935  * @brief Builds and sends the ULRRCMessageTransfer
1936  *
1937  * @details
1938  *
1939  *    Function : BuildAndSendULRRCMessageTransfer
1940  *
1941  *    Functionality: Constructs the UL RRC Message Transfer and sends
1942  *                   it to the CU through SCTP.
1943  *
1944  * @params[in]
1945  *
1946  * @return ROK     - success
1947  *         RFAILED - failure
1948  *
1949  * ****************************************************************/
1950 uint8_t BuildAndSendULRRCMessageTransfer()
1951 {
1952         uint8_t   elementCnt;
1953         uint8_t   idx1;
1954         uint8_t   idx;
1955         F1AP_PDU_t                              *f1apMsg = NULL;
1956    ULRRCMessageTransfer_t       *ulRRCMsg;
1957         asn_enc_rval_t                          encRetVal;        /* Encoder return value */
1958    uint8_t ret =RFAILED;
1959         while(1)
1960         {
1961            DU_LOG("\n F1AP : Building UL RRC Message Transfer Message\n");
1962
1963            DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1964            if(f1apMsg == NULLP)
1965            {
1966                    DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
1967                         break;
1968            }
1969
1970            f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1971         DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1972            if(f1apMsg->choice.initiatingMessage == NULLP)
1973            {
1974                    DU_LOG(" F1AP : Memory allocation for        F1AP-PDU failed");
1975                         break;
1976            }
1977         f1apMsg->choice.initiatingMessage->procedureCode = \
1978                                                                                                 ProcedureCode_id_ULRRCMessageTransfer;
1979            f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1980            f1apMsg->choice.initiatingMessage->value.present = \
1981                                                                 InitiatingMessage__value_PR_ULRRCMessageTransfer;
1982            ulRRCMsg =
1983                     &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
1984            elementCnt = 3;
1985         ulRRCMsg->protocolIEs.list.count = elementCnt;
1986            ulRRCMsg->protocolIEs.list.size = \
1987                                                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
1988
1989             /* Initialize the F1Setup members */
1990            DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
1991            if(ulRRCMsg->protocolIEs.list.array == NULLP)
1992            {
1993                     DU_LOG(" F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
1994                          break;
1995         }
1996            for(idx=0; idx<elementCnt; idx++)
1997            {
1998                    DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
1999                 if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2000                    {
2001                            break;
2002                    }
2003            }
2004
2005            idx1 = 0;
2006
2007             /*GNB CU UE F1AP ID*/
2008            ulRRCMsg->protocolIEs.list.array[idx1]->id   = \
2009                                                                                  ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2010            ulRRCMsg->protocolIEs.list.array[idx1]->criticality  =       Criticality_reject;
2011            ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2012                                 ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2013         ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
2014
2015            /*GNB DU UE F1AP ID*/
2016            idx1++;
2017         ulRRCMsg->protocolIEs.list.array[idx1]->id      = \
2018                                                                                  ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2019            ulRRCMsg->protocolIEs.list.array[idx1]->criticality  =       Criticality_reject;
2020            ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2021                                 ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2022            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
2023
2024            /*SRBID*/
2025            idx1++;
2026            ulRRCMsg->protocolIEs.list.array[idx1]->id   = \
2027                                                                                                                  ProtocolIE_ID_id_SRBID;
2028            ulRRCMsg->protocolIEs.list.array[idx1]->criticality  =       Criticality_reject;
2029            ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2030                                                                 ULRRCMessageTransferIEs__value_PR_SRBID;
2031            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = UL_SRBID;
2032
2033            /*RRCContainer*/
2034            //YET TO FILL
2035
2036            xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2037
2038            /* Encode the F1SetupRequest type as APER */
2039            cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2040            encBufSize = 0;
2041            encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2042                         encBuf);
2043            /* Encode results */
2044            if(encRetVal.encoded == ENCODE_FAIL)
2045            {
2046                      DU_LOG( "\n F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2047                                 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2048                           break;
2049            }
2050            else
2051            {
2052                     DU_LOG("\n F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2053                     for(int i=0; i< encBufSize; i++)
2054                     {
2055                              printf("%x",encBuf[i]);
2056                     }
2057            }
2058
2059            /* Sending  msg  */
2060            if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL)    !=      ROK)
2061            {
2062                     DU_LOG("\n F1AP : Sending   UL RRC Message Transfer Failed");
2063                          break;
2064                 }
2065       ret = ROK;
2066                 break;
2067         }
2068    FreeULRRCMessageTransfer(f1apMsg);
2069
2070         return ret;
2071 }/* End of BuildAndSendULRRCMessageTransfer*/
2072
2073 /*******************************************************************
2074 *
2075 * @brief Builds tag config
2076 *
2077 * @details
2078 *
2079 *    Function : BuildTagConfig
2080 *
2081 *    Functionality: Builds tag config in MacCellGroupConfig
2082 *
2083 * @params[in] TAG_Config *tag_Config
2084 *
2085 * @return ROK     - success
2086 *         RFAILED - failure
2087 *
2088 * ****************************************************************/
2089 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2090 {
2091         struct TAG_Config__tag_ToAddModList *tagList;
2092    uint8_t                     idx, elementCnt;
2093
2094    tagConfig->tag_ToReleaseList = NULLP;
2095    tagConfig->tag_ToAddModList = NULLP;
2096    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2097         if(!tagConfig->tag_ToAddModList)
2098         {
2099                 DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
2100                 return RFAILED;
2101         }
2102
2103         elementCnt = 1; //ODU_VALUE_ONE;
2104         tagList = tagConfig->tag_ToAddModList;
2105         tagList->list.count = elementCnt;
2106         tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2107
2108    tagList->list.array = NULLP;
2109         DU_ALLOC(tagList->list.array, tagList->list.size);
2110         if(!tagList->list.array)
2111         {
2112                 DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
2113                 return RFAILED;
2114         }
2115
2116         for(idx=0; idx<tagList->list.count; idx++)
2117         {
2118            tagList->list.array[idx] = NULLP;
2119                 DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2120                 if(!tagList->list.array[idx])
2121                 {
2122                         DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
2123                         return RFAILED;
2124                 }
2125         }
2126
2127         idx = 0;
2128         tagList->list.array[idx]->tag_Id = TAG_ID;
2129         tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2130
2131    return ROK;
2132 }
2133
2134 /*******************************************************************
2135 *
2136 * @brief Builds PHR Config
2137 *
2138 * @details
2139 *
2140 *    Function : BuildPhrConfig
2141 *
2142 *    Functionality: Builds phrConfig in MacCellGroupConfig
2143 *
2144 * @params[in] PHR Config *
2145 *
2146 * @return ROK     - success
2147 *         RFAILED - failure
2148 *
2149 * ****************************************************************/
2150 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2151 {
2152
2153    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2154         phrConfig->choice.setup = NULLP;
2155         DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2156         if(!phrConfig->choice.setup)
2157         {
2158                 DU_LOG("\nF1AP : Memory allocation failure in BuildPhrConfig");
2159                 return RFAILED;
2160         }
2161
2162         phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2163         phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2164    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2165         phrConfig->choice.setup->multiplePHR              = false;
2166         phrConfig->choice.setup->dummy                    = false;
2167         phrConfig->choice.setup->phr_Type2OtherCell       = false;
2168         phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2169
2170         return ROK;
2171 }
2172
2173 /*******************************************************************
2174 *
2175 * @brief Builds BSR Config
2176 *
2177 * @details
2178 *
2179 *    Function : BuildBsrConfig
2180 *
2181 *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2182 *
2183 * @params[in] BSR_Config *bsrConfig
2184 *
2185 * @return ROK     - success
2186 *         RFAILED - failure
2187 *
2188 * ****************************************************************/
2189 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2190 {
2191    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2192         bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2193         bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2194
2195    return ROK;
2196 }
2197
2198 /*******************************************************************
2199 *
2200 * @brief Builds scheduling request config
2201 *
2202 * @details
2203 *
2204 *    Function : BuildSchedulingReqConfig
2205 *
2206 *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2207 *
2208 * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2209 *
2210 * @return ROK     - success
2211 *         RFAILED - failure
2212 *
2213 * ****************************************************************/
2214 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
2215 {
2216         struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2217    uint8_t                     idx, elementCnt;
2218
2219    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2220         DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2221                         sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2222         if(!schedulingRequestConfig->schedulingRequestToAddModList)
2223         {
2224                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2225                 return RFAILED;
2226         }
2227
2228         elementCnt = 1; //ODU_VALUE_ONE;
2229         schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2230         schReqList->list.count = elementCnt;
2231    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2232
2233    schReqList->list.array = NULLP;
2234    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2235         if(!schReqList->list.array)
2236         {
2237                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2238                 return RFAILED;
2239         }
2240
2241    for(idx=0;idx<schReqList->list.count; idx++)
2242         {
2243            schReqList->list.array[idx] = NULLP;
2244                 DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2245                 if(!schReqList->list.array[idx])
2246                 {
2247                         DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2248                         return RFAILED;
2249                 }
2250         }
2251
2252         idx = 0;
2253         schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2254
2255    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2256         DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2257         if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2258         {
2259                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2260                 return RFAILED;
2261         }
2262    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2263         schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2264         schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2265
2266         return ROK;
2267 }
2268
2269 /*******************************************************************
2270 *
2271 * @brief Builds RLC Config
2272 *
2273 * @details
2274 *
2275 *    Function : BuildRlcConfig
2276 *
2277 *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
2278 *
2279 * @params[in] RLC_Config *rlcConfig
2280 *
2281 * @return ROK     - success
2282 *         RFAILED - failure
2283 *
2284 * ****************************************************************/
2285 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
2286 {
2287
2288    rlcConfig->present = RLC_Config_PR_am;
2289
2290    rlcConfig->choice.am = NULLP;
2291    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2292         if(!rlcConfig->choice.am)
2293         {
2294                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
2295                 return RFAILED;
2296         }
2297
2298    /* UL */
2299         rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2300    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2301         if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2302         {
2303                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
2304                 return RFAILED;
2305         }
2306    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2307         rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2308         rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2309         rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2310         rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2311
2312    /* DL */
2313    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2314    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2315         if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2316         {
2317                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
2318                 return RFAILED;
2319         }
2320         *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2321    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
2322         rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
2323
2324    return ROK;
2325 }
2326
2327 /*******************************************************************
2328 *
2329 * @brief Builds MAC LC Config
2330 *
2331 * @details
2332 *
2333 *    Function : BuildMacLCConfig
2334 *
2335 *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
2336 *
2337 * @params[in] struct LogicalChannelConfig macLcConfig
2338 *
2339 * @return ROK     - success
2340 *         RFAILED - failure
2341 *
2342 * ****************************************************************/
2343 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
2344 {
2345
2346    macLcConfig->ul_SpecificParameters = NULLP;
2347    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
2348         if(!macLcConfig->ul_SpecificParameters)
2349         {
2350                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
2351                 return RFAILED;
2352         }
2353
2354    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
2355         macLcConfig->ul_SpecificParameters->prioritisedBitRate =        PRIORTISIED_BIT_RATE;
2356         macLcConfig->ul_SpecificParameters->bucketSizeDuration =        BUCKET_SIZE_DURATION;
2357    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
2358         macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
2359         macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
2360    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
2361
2362    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
2363    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
2364    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
2365         {
2366                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
2367                 return RFAILED;
2368         }
2369    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
2370
2371    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
2372         DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,       sizeof(SchedulingRequestId_t));
2373         if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
2374         {
2375                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
2376                 return RFAILED;
2377         }
2378    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
2379
2380         macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
2381         macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
2382         macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
2383
2384    return ROK;
2385 }
2386
2387 /*******************************************************************
2388 *
2389 * @brief Builds RLC Bearer to Add/Mod list
2390 *
2391 * @details
2392 *
2393 *    Function :BuildRlcBearerToAddModList
2394 *
2395 *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
2396 *
2397 * @params[in] rlc_BearerToAddModList
2398 *
2399 * @return ROK     - success
2400 *         RFAILED - failure
2401 *
2402 * ****************************************************************/
2403 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
2404 {
2405    uint8_t                     idx, elementCnt;
2406
2407    elementCnt = 1;
2408    rlcBearerList->list.count = elementCnt;
2409         rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
2410
2411    rlcBearerList->list.array = NULLP;
2412         DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
2413         if(!rlcBearerList->list.array)
2414         {
2415                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2416                 return RFAILED;
2417         }
2418
2419    for(idx=0; idx<rlcBearerList->list.count; idx++)
2420         {
2421            rlcBearerList->list.array[idx] = NULLP;
2422                 DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
2423                 if(!rlcBearerList->list.array[idx])
2424                 {
2425                         DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2426                         return RFAILED;
2427                 }
2428         }
2429
2430    idx = 0;
2431         rlcBearerList->list.array[idx]->logicalChannelIdentity = RLC_LCID;
2432
2433         DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
2434         if(!rlcBearerList->list.array[idx]->servedRadioBearer)
2435         {
2436                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2437                 return RFAILED;
2438         }
2439
2440         rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
2441    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB_ID_1;
2442
2443    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
2444    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
2445    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
2446         if(!rlcBearerList->list.array[idx]->rlc_Config)
2447         {
2448                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2449                 return RFAILED;
2450         }
2451
2452    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
2453         {
2454                 DU_LOG("\nF1AP : BuildRlcConfig failed");
2455                 return RFAILED;
2456         }
2457
2458    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
2459    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
2460         if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
2461         {
2462                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2463                 return RFAILED;
2464         }
2465
2466         if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
2467         {
2468                 DU_LOG("\nF1AP : BuildMacLCConfig failed");
2469                 return RFAILED;
2470         }
2471
2472         return ROK;
2473 }
2474
2475 /*******************************************************************
2476  *
2477  * @brief Build Control resource set to add/modify list
2478  *
2479  * @details
2480  *
2481  *    Function : BuildControlRSetToAddModList
2482  *
2483  *    Functionality: Build Control resource set to add/modify list
2484  *
2485  * @params[in]
2486  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2487  *
2488  * @return ROK     - success
2489  *         RFAILED - failure
2490  *
2491  * ****************************************************************/
2492 uint8_t BuildControlRSetToAddModList
2493 (
2494 struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2495 )
2496 {
2497    uint8_t idx;
2498    uint8_t elementCnt;
2499         uint8_t numBytes;
2500         uint8_t byteIdx;
2501         uint8_t bitsUnused;
2502    struct ControlResourceSet *controlRSet;
2503
2504    elementCnt = 1;
2505    controlRSetList->list.count = elementCnt;
2506    controlRSetList->list.size = \
2507        elementCnt * sizeof(struct ControlResourceSet *);
2508
2509    controlRSetList->list.array = NULLP;
2510    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
2511    if(!controlRSetList->list.array)
2512    {
2513       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2514       return RFAILED;
2515    }
2516
2517    for(idx = 0; idx < elementCnt; idx++)
2518    {
2519            controlRSetList->list.array[idx] = NULLP;
2520       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
2521       if(!controlRSetList->list.array[idx])
2522       {
2523          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2524          return RFAILED;
2525       }
2526    }
2527
2528    idx=0;
2529    controlRSet = controlRSetList->list.array[idx];
2530
2531    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
2532
2533         /* Values taken from reference logs :
2534          * size 6 bytes
2535          * 3 LSBs unsued
2536          * Bit string stored ff0000000000
2537          */
2538         numBytes = 6;
2539    bitsUnused = 3;
2540    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
2541
2542    controlRSet->frequencyDomainResources.buf = NULLP;
2543         DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
2544            controlRSet->frequencyDomainResources.size);
2545         if(!controlRSet->frequencyDomainResources.buf)
2546         {
2547            DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2548                 return RFAILED;
2549    }
2550    byteIdx = 0;
2551         controlRSet->frequencyDomainResources.buf[byteIdx] = PDCCH_FREQ_DOM_RSRC; /* setting 8 MSBs i.e. ff */
2552    for(byteIdx = 1; byteIdx < numBytes; byteIdx++)
2553         {
2554            controlRSet->frequencyDomainResources.buf[byteIdx] = 0;
2555         }
2556         controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
2557
2558    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
2559    controlRSet->cce_REG_MappingType.present = \
2560       ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
2561
2562    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
2563    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
2564         controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
2565         controlRSet->tci_PresentInDCI = NULLP;
2566 #if 0
2567    uint8_t tciStateIdx;
2568
2569    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
2570       sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
2571    if(!controlRset->tci_StatesPDCCH_ToAddList)
2572    {
2573       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2574       return RFAILED;
2575    }
2576
2577    elementCnt = 1;
2578    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
2579    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
2580    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
2581       controlRset->tci_StatesPDCCH_ToAddList->list.size)
2582    if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
2583    {
2584       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2585       return RFAILED;
2586    }
2587
2588    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
2589    {
2590       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
2591       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
2592       {
2593          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2594          return RFAILED;
2595       }
2596    }
2597
2598    tciStateIdx = 0;
2599    /* TODO */
2600    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
2601
2602    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
2603    if(!controlRset->tci_PresentInDCI)
2604    {
2605       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2606       return RFAILED;
2607    }
2608    /* TODO */
2609    *(controlRset->tci_PresentInDCI);
2610 #endif
2611
2612    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
2613    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
2614    if(!controlRSet->pdcch_DMRS_ScramblingID)
2615    {
2616       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2617       return RFAILED;
2618    }
2619    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
2620
2621    return ROK;
2622 } /* End BuildControlRSetToAddModList */
2623
2624 /*******************************************************************
2625  *
2626  * @brief Build search space to add/modify list
2627  *
2628  * @details
2629  *
2630  *    Function : BuildSearchSpcToAddModList
2631  *
2632  *    Functionality: Build search space to add/modify list
2633  *
2634  * @params[in]
2635  * @return ROK     - success
2636  *         RFAILED - failure
2637  *
2638  * ****************************************************************/
2639 uint8_t BuildSearchSpcToAddModList
2640 (
2641 struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
2642 )
2643 {
2644    uint8_t idx;
2645         uint8_t numBytes;
2646         uint8_t byteIdx;
2647         uint8_t bitsUnused;
2648    uint8_t elementCnt;
2649    struct SearchSpace *searchSpc;
2650
2651    elementCnt = 1;
2652    searchSpcList->list.count = elementCnt;
2653    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
2654
2655         searchSpcList->list.array = NULLP;
2656    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
2657    if(!searchSpcList->list.array)
2658    {
2659       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2660       return RFAILED;
2661    }
2662
2663    for(idx = 0; idx < elementCnt; idx++)
2664    {
2665            searchSpcList->list.array[idx] = NULLP;
2666       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
2667       if(!searchSpcList->list.array[idx])
2668       {
2669          DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2670          return RFAILED;
2671       }
2672    }
2673
2674    idx = 0;
2675    searchSpc = searchSpcList->list.array[idx];
2676
2677    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
2678
2679    searchSpc->controlResourceSetId = NULLP;
2680    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
2681    if(!searchSpc->controlResourceSetId)
2682    {
2683       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2684       return RFAILED;
2685    }
2686    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
2687
2688    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
2689    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
2690       sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
2691    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
2692         {
2693            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2694                 return RFAILED;
2695         }
2696    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
2697            SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
2698
2699    searchSpc->duration = NULLP;
2700    searchSpc->monitoringSymbolsWithinSlot = NULLP;
2701         DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
2702         if(!searchSpc->monitoringSymbolsWithinSlot)
2703         {
2704            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2705                 return RFAILED;
2706         }
2707
2708         /* Values taken from reference logs :
2709          * size 2 bytes
2710          * 2 LSBs unsued
2711          * Bit string stores 8000
2712          */
2713    numBytes = 2;
2714         bitsUnused = 2;
2715
2716    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
2717         searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
2718         DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
2719            searchSpc->monitoringSymbolsWithinSlot->size);
2720         if(!searchSpc->monitoringSymbolsWithinSlot->buf)
2721         {
2722            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2723                 return RFAILED;
2724         }
2725
2726         byteIdx = 0;
2727         searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
2728          PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
2729         searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
2730         searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
2731
2732    searchSpc->nrofCandidates = NULLP;
2733    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
2734    if(!searchSpc->nrofCandidates)
2735    {
2736       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2737       return RFAILED;
2738    }
2739
2740    searchSpc->nrofCandidates->aggregationLevel1 = \
2741            PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
2742    searchSpc->nrofCandidates->aggregationLevel2 = \
2743            PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
2744    searchSpc->nrofCandidates->aggregationLevel4 = \
2745            PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
2746    searchSpc->nrofCandidates->aggregationLevel8 = \
2747            PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
2748    searchSpc->nrofCandidates->aggregationLevel16 = \
2749            PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
2750
2751    searchSpc->searchSpaceType = NULLP;
2752    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
2753    if(!searchSpc->searchSpaceType)
2754    {
2755       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2756       return RFAILED;
2757    }
2758
2759    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
2760
2761    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
2762    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
2763       sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
2764    if(!searchSpc->searchSpaceType->choice.ue_Specific)
2765    {
2766       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2767       return RFAILED;
2768    }
2769    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
2770            PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
2771
2772    return ROK;
2773 }/* End BuildSearchSpcToAddModList */
2774
2775 /*******************************************************************
2776  *
2777  * @brief Builds BWP DL dedicated PDCCH config
2778  *
2779  * @details
2780  *
2781  *    Function : BuildBWPDlDedPdcchCfg
2782  *
2783  *    Functionality: Builds BWP DL dedicated PDCCH config
2784  *
2785  * @params[in] struct PDCCH_Config *pdcchCfg
2786  *
2787  * @return ROK     - success
2788  *         RFAILED - failure
2789  *
2790  * ****************************************************************/
2791 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
2792 {
2793    pdcchCfg->controlResourceSetToAddModList = NULLP;
2794    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
2795       sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
2796    if(!pdcchCfg->controlResourceSetToAddModList)
2797    {
2798       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
2799       return RFAILED;
2800    }
2801
2802         if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
2803         {
2804            return RFAILED;
2805         }
2806
2807    pdcchCfg->controlResourceSetToReleaseList = NULLP;
2808
2809    pdcchCfg->searchSpacesToAddModList = NULLP;
2810         DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
2811            sizeof(struct PDCCH_Config__searchSpacesToAddModList));
2812         if(!pdcchCfg->searchSpacesToAddModList)
2813         {
2814            DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
2815                 return RFAILED;
2816         }
2817
2818         if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
2819         {
2820            return RFAILED;
2821         }
2822
2823    pdcchCfg->searchSpacesToReleaseList = NULLP;
2824         pdcchCfg->downlinkPreemption = NULLP;
2825         pdcchCfg->tpc_PUSCH = NULLP;
2826         pdcchCfg->tpc_PUCCH = NULLP;
2827         pdcchCfg->tpc_SRS = NULLP;
2828
2829    return ROK;
2830 }
2831
2832 /*******************************************************************
2833  *
2834  * @brief Builds DMRS DL PDSCH Mapping type A
2835  *
2836  * @details
2837  *
2838  *    Function : BuildDMRSDLPdschMapTypeA
2839  *
2840  *    Functionality: Builds DMRS DL PDSCH Mapping type A
2841  *
2842  * @params[in]
2843  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
2844  * @return ROK     - success
2845  *         RFAILED - failure
2846  *
2847  * ****************************************************************/
2848 uint8_t BuildDMRSDLPdschMapTypeA
2849 (
2850 struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
2851 )
2852 {
2853    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
2854         dmrsDlCfg->choice.setup = NULLP;
2855    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
2856    if(!dmrsDlCfg->choice.setup)
2857    {
2858       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
2859       return RFAILED;
2860    }
2861
2862         dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
2863         dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
2864    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
2865    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
2866    {
2867       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
2868       return RFAILED;
2869    }
2870    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
2871
2872         dmrsDlCfg->choice.setup->maxLength = NULLP;
2873         dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
2874         dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
2875         dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
2876
2877    return ROK;
2878 }
2879
2880 /*******************************************************************
2881  *
2882  * @brief Builds TCI states to add/modify list
2883  *
2884  * @details
2885  *
2886  *    Function : BuildTCIStatesToAddModList
2887  *
2888  *    Functionality:Builds TCI states to add/modify list
2889  *
2890  * @params[in]
2891  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
2892  *
2893  * @return ROK     - success
2894  *         RFAILED - failure
2895  *
2896  * ****************************************************************/
2897 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
2898 {
2899    return ROK;
2900 }
2901
2902 /*******************************************************************
2903  *
2904  * @brief Builds PDSCH time domain allocation list
2905  *
2906  * @details
2907  *
2908  *    Function : BuildPdschTimeDomAllocList
2909  *
2910  *    Functionality: Builds PDSCH time domain allocation list
2911  *
2912  * @params[in]
2913  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
2914  *
2915  * @return ROK     - success
2916  *         RFAILED - failure
2917  *
2918  * ****************************************************************/
2919 uint8_t BuildPdschTimeDomAllocList
2920 (
2921 struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
2922 )
2923 {
2924    uint8_t idx;
2925    uint8_t elementCnt;
2926         struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
2927
2928    timeDomAllocList->present = \
2929            PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
2930
2931    timeDomAllocList->choice.setup = NULLP;
2932    DU_ALLOC(timeDomAllocList->choice.setup, \
2933            sizeof(struct PDSCH_TimeDomainResourceAllocationList));
2934    if(!timeDomAllocList->choice.setup)
2935         {
2936            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
2937                 return RFAILED;
2938         }
2939
2940         elementCnt = 1;
2941         timeDomAllocList->choice.setup->list.count = elementCnt;
2942         timeDomAllocList->choice.setup->list.size = \
2943            elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
2944
2945         timeDomAllocList->choice.setup->list.array = NULLP;
2946         DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
2947            timeDomAllocList->choice.setup->list.size);
2948         if(!timeDomAllocList->choice.setup->list.array)
2949         {
2950            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
2951                 return RFAILED;
2952         }
2953
2954         for(idx = 0; idx < elementCnt; idx++)
2955         {
2956            timeDomAllocList->choice.setup->list.array[idx] = NULLP;
2957            DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
2958                    sizeof(struct PDSCH_TimeDomainResourceAllocation));
2959                 if(!timeDomAllocList->choice.setup->list.array[idx])
2960                 {
2961                    DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
2962                         return RFAILED;
2963                 }
2964         }
2965
2966         idx = 0;
2967         timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
2968
2969    timeDomAlloc->k0 = NULLP;
2970         timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
2971         timeDomAlloc->startSymbolAndLength = \
2972            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
2973
2974    return ROK;
2975 }
2976
2977 /*******************************************************************
2978  *
2979  * @brief Builds PDSCH PRB Bundling type
2980  *
2981  * @details
2982  *
2983  *    Function : BuildPdschPrbBundlingType
2984  *
2985  *    Functionality: Builds PDSCH PRB Bundling type
2986  *
2987  * @params[in]
2988  * struct PDSCH_Config__prb_BundlingType *prbBndlType
2989  *
2990  * @return ROK     - success
2991  *         RFAILED - failure
2992  *
2993  * ****************************************************************/
2994 uint8_t BuildPdschPrbBundlingType
2995 (
2996 struct PDSCH_Config__prb_BundlingType *prbBndlType
2997 )
2998 {
2999    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3000
3001    prbBndlType->choice.staticBundling = NULLP;
3002         DU_ALLOC(prbBndlType->choice.staticBundling, \
3003            sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3004         if(!prbBndlType->choice.staticBundling)
3005         {
3006            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3007                 return RFAILED;
3008         }
3009         prbBndlType->choice.staticBundling->bundleSize = NULLP;
3010
3011    return ROK;
3012 }
3013
3014 /*******************************************************************
3015  *
3016  * @brief Builds BWP DL dedicated PDSCH config
3017  *
3018  * @details
3019  *
3020  *    Function : BuildBWPDlDedPdschCfg
3021  *
3022  *    Functionality: Builds BWP DL dedicated PDSCH config
3023  *
3024  * @params[in] struct PDSCH_Config *pdschCfg
3025  *
3026  * @return ROK     - success
3027  *         RFAILED - failure
3028  *
3029  * ****************************************************************/
3030 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3031 {
3032    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3033
3034    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3035    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3036       sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3037    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3038    {
3039       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3040       return RFAILED;
3041    }
3042
3043    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3044    {
3045       return RFAILED;
3046    }
3047
3048    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3049    pdschCfg->tci_StatesToAddModList = NULLP;
3050    pdschCfg->tci_StatesToReleaseList = NULLP;
3051         pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3052 #if 0
3053    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3054    if(!pdschCfg->tci_StatesToAddModList)
3055    {
3056       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3057       return RFAILED;
3058    }
3059    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3060    {
3061       return RFAILED;
3062    }
3063 #endif
3064
3065         pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3066
3067    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3068         DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3069            sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3070    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3071         {
3072       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3073                 return RFAILED;
3074         }
3075
3076         if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3077         {
3078            return RFAILED;
3079         }
3080
3081    pdschCfg->pdsch_AggregationFactor = NULLP;
3082         pdschCfg->rateMatchPatternToAddModList = NULLP;
3083         pdschCfg->rateMatchPatternToReleaseList = NULLP;
3084         pdschCfg->rateMatchPatternGroup1 = NULLP;
3085         pdschCfg->rateMatchPatternGroup2 = NULLP;
3086         pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3087         pdschCfg->mcs_Table = NULLP;
3088
3089         pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3090         DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3091         if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3092         {
3093            DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3094                 return RFAILED;
3095         }
3096         *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3097
3098         if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3099         {
3100            return RFAILED;
3101         }
3102
3103         pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3104         pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3105         pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3106         pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3107         pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3108         pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3109    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3110
3111    return ROK;
3112 }
3113
3114 /*******************************************************************
3115  *
3116  * @brief Builds intitial DL BWP
3117  * @details
3118  *
3119  *    Function : BuildInitialDlBWP
3120  *
3121  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3122  *
3123  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3124  *
3125  * @return ROK     - success
3126  *         RFAILED - failure
3127  *
3128  * ****************************************************************/
3129 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3130 {
3131    dlBwp->pdcch_Config = NULLP;
3132    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3133         if(!dlBwp->pdcch_Config)
3134         {
3135            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3136       return RFAILED;
3137         }
3138         dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3139
3140    dlBwp->pdcch_Config->choice.setup = NULLP;
3141         DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3142    if(!dlBwp->pdcch_Config->choice.setup)
3143    {
3144            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3145                 return RFAILED;
3146         }
3147    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3148         {
3149            return RFAILED;
3150         }
3151
3152    dlBwp->pdsch_Config = NULLP;
3153         DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3154         if(!dlBwp->pdsch_Config)
3155         {
3156            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3157                 return RFAILED;
3158         }
3159         dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3160
3161    dlBwp->pdsch_Config->choice.setup = NULLP;
3162    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3163    if(!dlBwp->pdsch_Config->choice.setup)
3164    {
3165       DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3166                 return RFAILED;
3167         }
3168
3169    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3170         {
3171            return RFAILED;
3172         }
3173
3174    dlBwp->sps_Config = NULLP;
3175    dlBwp->radioLinkMonitoringConfig = NULLP;
3176    return ROK;
3177 }
3178
3179 /*******************************************************************
3180  *
3181  * @brief Builds DMRS UL Pusch Mapping type A
3182  *
3183  * @details
3184  *
3185  *    Function : BuildDMRSULPuschMapTypeA
3186  *
3187  *    Functionality: Builds DMRS UL Pusch Mapping type A
3188  *
3189  * @params[in]
3190  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3191  * @return ROK     - success
3192  *         RFAILED - failure
3193  *
3194  * ****************************************************************/
3195 uint8_t BuildDMRSULPuschMapTypeA
3196 (
3197 struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3198 )
3199 {
3200    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3201    dmrsUlCfg->choice.setup= NULLP;
3202    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3203    if(!dmrsUlCfg->choice.setup)
3204    {
3205       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3206       return RFAILED;
3207    }
3208
3209    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3210         dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3211    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3212    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3213    {
3214       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3215       return RFAILED;
3216    }
3217    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3218
3219         dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3220         dmrsUlCfg->choice.setup->maxLength = NULLP;
3221    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3222    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3223       sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3224    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3225    {
3226       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3227       return RFAILED;
3228    }
3229
3230    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3231    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3232       sizeof(long));
3233    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3234    {
3235       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3236       return RFAILED;
3237    }
3238    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3239
3240         dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3241         dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3242    return ROK;
3243 }
3244
3245 /*******************************************************************
3246  *
3247  * @brief Build PUSCH time domain allocation list
3248  *
3249  * @details
3250  *
3251  *    Function : BuildPuschTimeDomAllocList
3252  *
3253  *    Functionality: Build PUSCH time domain allocation list
3254  *
3255  * @params[in]
3256  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3257  *
3258  * @return ROK     - success
3259  *         RFAILED - failure
3260  *
3261  * ****************************************************************/
3262 uint8_t BuildPuschTimeDomAllocList
3263 (
3264 struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3265 )
3266 {
3267    uint8_t idx;
3268    uint8_t elementCnt;
3269    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3270
3271    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3272    timeDomAllocList->choice.setup = NULLP;
3273    DU_ALLOC(timeDomAllocList->choice.setup, \
3274       sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3275    if(!timeDomAllocList->choice.setup)
3276    {
3277       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3278       return RFAILED;
3279    }
3280
3281    elementCnt = 1;
3282    timeDomAllocList->choice.setup->list.count = elementCnt;
3283    timeDomAllocList->choice.setup->list.size = \
3284       elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3285         timeDomAllocList->choice.setup->list.array = NULLP;
3286    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3287       timeDomAllocList->choice.setup->list.size);
3288    if(!timeDomAllocList->choice.setup->list.array)
3289    {
3290       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3291       return RFAILED;
3292    }
3293
3294    for(idx = 0; idx < elementCnt; idx++)
3295    {
3296            timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3297       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3298          sizeof(PUSCH_TimeDomainResourceAllocation_t));
3299       if(!timeDomAllocList->choice.setup->list.array[idx])
3300       {
3301          DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3302          return RFAILED;
3303       }
3304    }
3305
3306    idx = 0;
3307    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3308    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
3309    if(!timeDomAlloc->k2)
3310    {
3311       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3312       return RFAILED;
3313    }
3314    *(timeDomAlloc->k2) = PUSCH_K2;
3315    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3316    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
3317    return ROK;
3318 }
3319
3320 /*******************************************************************
3321  *
3322  * @brief Builds BWP UL dedicated PUSCH Config
3323  *
3324  * @details
3325  *
3326  *    Function : BuildBWPUlDedPuschCfg
3327  *
3328  *    Functionality:
3329  *      Builds BWP UL dedicated PUSCH Config
3330  *
3331  * @params[in] : PUSCH_Config_t *puschCfg
3332  *
3333  * @return ROK     - success
3334  *         RFAILED - failure
3335  *
3336  * ****************************************************************/
3337 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3338 {
3339    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3340    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3341    if(!puschCfg->dataScramblingIdentityPUSCH)
3342    {
3343       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3344       return RFAILED;
3345    }
3346    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3347
3348    puschCfg->txConfig = NULLP;
3349         puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3350    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3351       sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3352    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3353    {
3354       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3355       return RFAILED;
3356    }
3357
3358    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
3359    {
3360       return RFAILED;
3361    }
3362
3363    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
3364         puschCfg->pusch_PowerControl = NULLP;
3365         puschCfg->frequencyHopping = NULLP;
3366         puschCfg->frequencyHoppingOffsetLists = NULLP;
3367    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
3368
3369    puschCfg->pusch_TimeDomainAllocationList = NULLP;
3370    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
3371       sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
3372    if(!puschCfg->pusch_TimeDomainAllocationList)
3373    {
3374       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3375       return RFAILED;
3376    }
3377
3378    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
3379    {
3380       return RFAILED;
3381    }
3382
3383    puschCfg->pusch_AggregationFactor = NULLP;
3384         puschCfg->mcs_Table = NULLP;
3385         puschCfg->mcs_TableTransformPrecoder = NULLP;
3386    puschCfg->transformPrecoder = NULLP;
3387    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
3388    if(!puschCfg->transformPrecoder)
3389    {
3390       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3391       return RFAILED;
3392    }
3393    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
3394
3395         puschCfg->codebookSubset = NULLP;
3396         puschCfg->maxRank = NULLP;
3397         puschCfg->rbg_Size = NULLP;
3398         puschCfg->uci_OnPUSCH = NULLP;
3399         puschCfg->tp_pi2BPSK = NULLP;
3400
3401    return ROK;
3402 }
3403
3404 /*******************************************************************
3405  *
3406  * @brief Fills SRS resource to add/modify list
3407  *
3408  * @details
3409  *
3410  *    Function : BuildSrsRsrcAddModList
3411  *
3412  *    Functionality: Fills SRS resource to add/modify list
3413  *
3414  * @params[in]
3415  * @return ROK     - success
3416  *         RFAILED - failure
3417  *
3418  * ****************************************************************/
3419 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
3420 {
3421    uint8_t   elementCnt;
3422    uint8_t   rsrcIdx;
3423
3424    elementCnt = 1;
3425    resourceList->list.count = elementCnt;
3426    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
3427    resourceList->list.array = NULLP;
3428    DU_ALLOC(resourceList->list.array, resourceList->list.size);
3429    if(!resourceList->list.array)
3430    {
3431       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3432       return RFAILED;
3433    }
3434
3435    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
3436    {
3437       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
3438       if(!resourceList->list.array[rsrcIdx])
3439       {
3440          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3441          return RFAILED;
3442       }
3443    }
3444
3445    rsrcIdx = 0;
3446    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
3447    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
3448    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
3449
3450    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
3451    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
3452       sizeof(struct SRS_Resource__transmissionComb__n2));
3453    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
3454    {
3455       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3456       return RFAILED;
3457    }
3458    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
3459            = SRS_COMB_OFFSET_N2;
3460    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
3461            = SRS_CYCLIC_SHIFT_N2;
3462
3463    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
3464            PUSCH_START_SYMBOL;
3465    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
3466       SRS_Resource__resourceMapping__nrofSymbols_n1;
3467    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
3468       SRS_Resource__resourceMapping__repetitionFactor_n1;
3469
3470    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
3471    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
3472    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
3473    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
3474    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
3475    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
3476       SRS_Resource__groupOrSequenceHopping_neither;
3477
3478    /* Setting resource type to aperiodic for intergration purposes */
3479    resourceList->list.array[rsrcIdx]->resourceType.present = \
3480            SRS_Resource__resourceType_PR_aperiodic;
3481    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
3482    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
3483       sizeof(struct SRS_Resource__resourceType__aperiodic));
3484    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
3485    {
3486       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3487       return RFAILED;
3488    }
3489    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
3490
3491    return ROK;
3492 }
3493
3494 /*******************************************************************
3495  *
3496  * @brief Build SRS resource set Add/mod list
3497  *
3498  * @details
3499  *
3500  *    Function : BuildSrsRsrcSetAddModList
3501  *
3502  *    Functionality: Build SRS resource set Add/mod list
3503  *
3504  * @params[in]
3505  * @return ROK     - success
3506  *         RFAILED - failure
3507  *
3508  * ****************************************************************/
3509 uint8_t BuildSrsRsrcSetAddModList
3510 (
3511 struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
3512 )
3513 {
3514    uint8_t  elementCnt;
3515    uint8_t  rSetIdx;
3516         uint8_t  rsrcIdx;
3517         struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
3518
3519    elementCnt = 1;
3520    rsrcSetList->list.count = elementCnt;
3521    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
3522    rsrcSetList->list.array = NULLP;
3523    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
3524    if(!rsrcSetList->list.array)
3525    {
3526       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3527       return RFAILED;
3528    }
3529
3530    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
3531    {
3532       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
3533       if(!rsrcSetList->list.array[rSetIdx])
3534       {
3535          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3536          return RFAILED;
3537       }
3538    }
3539
3540    rSetIdx = 0;
3541    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
3542
3543         /* Fill Resource Id list in resource set */
3544         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
3545         DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
3546            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
3547         if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
3548         {
3549            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3550                 return RFAILED;
3551         }
3552
3553         elementCnt = 1;
3554         rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
3555         rsrcIdList->list.count = elementCnt;
3556         rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
3557         rsrcIdList->list.array = NULLP;
3558         DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
3559         if(!rsrcIdList->list.array)
3560         {
3561            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3562                 return RFAILED;
3563         }
3564
3565         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
3566         {
3567            DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
3568                 if(!rsrcIdList->list.array[rsrcIdx])
3569                 {
3570                    DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3571                         return RFAILED;
3572                 }
3573         }
3574
3575         rsrcIdx = 0;
3576         *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
3577
3578         /* Fill resource type */
3579    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
3580       SRS_ResourceSet__resourceType_PR_aperiodic;
3581
3582    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
3583    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
3584       sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
3585    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
3586    {
3587            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3588                 return RFAILED;
3589         }
3590    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
3591            = APERIODIC_SRS_RESRC_TRIGGER;
3592
3593         /* TODO : Fill values for below IEs as expected by Viavi */
3594         rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
3595    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
3596
3597
3598    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
3599         rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
3600         rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
3601         rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
3602         rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
3603
3604    return ROK;
3605 }
3606
3607 /*******************************************************************
3608  *
3609  * @brief Builds BWP UL dedicated SRS Config
3610  *
3611  * @details
3612  *
3613  *    Function : BuildBWPUlDedSrsCfg
3614  *
3615  *    Functionality: Builds BWP UL dedicated SRS Config
3616  *
3617  * @params[in] SRS Config
3618  * @return ROK     - success
3619  *         RFAILED - failure
3620  *
3621  * ****************************************************************/
3622 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
3623 {
3624    srsCfg->srs_ResourceSetToReleaseList = NULLP;
3625    srsCfg->srs_ResourceSetToAddModList = NULLP;
3626    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
3627       sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
3628    if(!srsCfg->srs_ResourceSetToAddModList)
3629    {
3630       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3631       return RFAILED;
3632    }
3633    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
3634    {
3635       return RFAILED;
3636    }
3637
3638    srsCfg->srs_ResourceToReleaseList = NULLP;
3639
3640    /* Resource to Add/Modify list */
3641    srsCfg->srs_ResourceToAddModList = NULLP;
3642    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
3643       sizeof(struct SRS_Config__srs_ResourceToAddModList));
3644    if(!srsCfg->srs_ResourceToAddModList)
3645    {
3646       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3647       return RFAILED;
3648    }
3649
3650    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
3651    {
3652       return RFAILED;
3653    }
3654
3655    srsCfg->tpc_Accumulation = NULLP;
3656
3657    return ROK;
3658 }
3659
3660 /*******************************************************************
3661  *
3662  * @brief Builds inital UL BWP
3663  *
3664  * @details
3665  *
3666  *    Function : BuildInitialUlBWP
3667  *
3668  *    Functionality: Builds initial UL BWP
3669  *
3670  * @params[in] BWP_UplinkDedicated_t *ulBwp
3671  * @return ROK     - success
3672  *         RFAILED - failure
3673  *
3674  * ****************************************************************/
3675 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
3676 {
3677    ulBwp->pucch_Config = NULLP;
3678
3679    /* Fill BWP UL dedicated PUSCH config */
3680         ulBwp->pusch_Config = NULLP;
3681    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
3682    if(!ulBwp->pusch_Config)
3683    {
3684       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3685       return RFAILED;
3686    }
3687
3688    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
3689    ulBwp->pusch_Config->choice.setup = NULLP;
3690    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
3691    if(!ulBwp->pusch_Config->choice.setup)
3692    {
3693       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3694       return RFAILED;
3695    }
3696
3697    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
3698    {
3699       return RFAILED;
3700    }
3701
3702         ulBwp->configuredGrantConfig = NULLP;
3703
3704    /* Fill BPW UL dedicated SRS config */
3705         ulBwp->srs_Config = NULLP;
3706    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
3707    if(!ulBwp->srs_Config)
3708    {
3709       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3710       return RFAILED;
3711    }
3712
3713    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
3714    ulBwp->srs_Config->choice.setup = NULLP;
3715    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
3716    if(!ulBwp->srs_Config->choice.setup)
3717    {
3718       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3719       return RFAILED;
3720    }
3721
3722    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
3723    {
3724       return RFAILED;
3725    }
3726
3727         ulBwp->beamFailureRecoveryConfig = NULLP;
3728
3729    return ROK;
3730 }
3731
3732 /*******************************************************************
3733 *
3734 * @brief Builds Pusch Serving cell Config
3735 *
3736 * @details
3737 *
3738 *    Function : BuildPuschSrvCellCfg
3739 *
3740 *    Functionality: Builds Pusch Serving cell Config
3741 *
3742 * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
3743 *
3744 * @return ROK     - success
3745 *         RFAILED - failure
3746 *
3747 * ****************************************************************/
3748 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
3749 {
3750    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
3751    puschCfg->choice.setup = NULLP;
3752    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
3753    if(!puschCfg->choice.setup)
3754    {
3755       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3756       return RFAILED;
3757    }
3758
3759    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
3760         puschCfg->choice.setup->rateMatching = NULLP;
3761         puschCfg->choice.setup->xOverhead = NULLP;
3762    puschCfg->choice.setup->ext1 = NULLP;
3763    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
3764    if(!puschCfg->choice.setup->ext1)
3765    {
3766       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3767       return RFAILED;
3768    }
3769
3770    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
3771    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
3772    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
3773    {
3774       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3775       return RFAILED;
3776    }
3777    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
3778
3779    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
3780    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
3781    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
3782    {
3783       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3784       return RFAILED;
3785    }
3786    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
3787    return ROK;
3788 }
3789
3790 /*******************************************************************
3791  *
3792  * @brief Builds UL config
3793  * @details
3794  *
3795  *    Function : BuildUlCfg
3796  *
3797  *    Functionality: Builds UL config in spCellCfgDed
3798  *
3799  * @params[in] UplinkConfig_t *ulCfg
3800  *
3801  * @return ROK     - success
3802  *         RFAILED - failure
3803  *
3804  * ****************************************************************/
3805 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
3806 {
3807    ulCfg->initialUplinkBWP = NULLP;
3808    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
3809         if(!ulCfg->initialUplinkBWP)
3810         {
3811            DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
3812                 return RFAILED;
3813         }
3814
3815    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
3816         {
3817            return RFAILED;
3818         }
3819
3820    ulCfg->uplinkBWP_ToReleaseList = NULLP;
3821         ulCfg->uplinkBWP_ToAddModList = NULLP;
3822         ulCfg->firstActiveUplinkBWP_Id = NULLP;
3823    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
3824    if(!ulCfg->firstActiveUplinkBWP_Id)
3825    {
3826       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
3827       return RFAILED;
3828    }
3829    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
3830
3831    ulCfg->pusch_ServingCellConfig = NULLP;
3832    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
3833       sizeof(struct UplinkConfig__pusch_ServingCellConfig));
3834    if(!ulCfg->pusch_ServingCellConfig)
3835    {
3836       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
3837       return RFAILED;
3838    }
3839
3840    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
3841    {
3842       return RFAILED;
3843    }
3844
3845         ulCfg->carrierSwitching = NULLP;
3846         ulCfg->ext1 = NULLP;
3847         return ROK;
3848 }
3849
3850 /*******************************************************************
3851  *
3852  * @brief Builds PDSCH serving cell config
3853  * @details
3854  *
3855  *    Function : BuildPdschSrvCellCfg
3856  *
3857  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
3858  *
3859  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
3860  *
3861  * @return ROK     - success
3862  *         RFAILED - failure
3863  *
3864  * ****************************************************************/
3865 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
3866 {
3867    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
3868    pdschCfg->choice.setup = NULLP;
3869    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
3870    if(!pdschCfg->choice.setup)
3871    {
3872       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
3873       return RFAILED;
3874    }
3875
3876    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
3877         pdschCfg->choice.setup->xOverhead = NULLP;
3878    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
3879    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
3880    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
3881    {
3882       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
3883       return RFAILED;
3884    }
3885    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
3886         pdschCfg->choice.setup->pucch_Cell = NULLP;
3887         pdschCfg->choice.setup->ext1 = NULLP;
3888
3889    return ROK;
3890 }
3891
3892 /*******************************************************************
3893  *
3894  * @brief Builds CSI Meas config
3895  * @details
3896  *
3897  *    Function : BuildCsiMeasCfg
3898  *
3899  *    Functionality: Builds CSI Meas config in spCellCfgDed
3900  *
3901  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
3902  *
3903  * @return ROK     - success
3904  *         RFAILED - failure
3905  *
3906  * ****************************************************************/
3907 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
3908 {
3909
3910    return ROK;
3911 }
3912
3913 /*******************************************************************
3914  *
3915  * @brief Builds Spcell config dedicated
3916  * @details
3917  *
3918  *    Function : BuildSpCellCfgDed
3919  *
3920  *    Functionality: Builds sp cell config dedicated in spCellCfg
3921  *
3922  * @params[in] ServingCellConfig_t srvCellCfg
3923  *
3924  * @return ROK     - success
3925  *         RFAILED - failure
3926  *
3927  * ****************************************************************/
3928 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
3929 {
3930    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
3931
3932    srvCellCfg->initialDownlinkBWP = NULLP;
3933    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
3934         if(!srvCellCfg->initialDownlinkBWP)
3935         {
3936                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
3937                 return RFAILED;
3938         }
3939
3940    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
3941         {
3942                 DU_LOG("\nF1AP : BuildInitialDlBWP failed");
3943                 return RFAILED;
3944         }
3945    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
3946         srvCellCfg->downlinkBWP_ToAddModList = NULLP;
3947
3948    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
3949         DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
3950         if(!srvCellCfg->firstActiveDownlinkBWP_Id)
3951         {
3952                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
3953                 return RFAILED;
3954         }
3955         *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
3956
3957         srvCellCfg->bwp_InactivityTimer = NULLP;
3958
3959    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
3960         DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
3961         if(!srvCellCfg->defaultDownlinkBWP_Id)
3962         {
3963                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
3964                 return RFAILED;
3965         }
3966         *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
3967
3968    srvCellCfg->uplinkConfig = NULLP;
3969    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
3970         if(!srvCellCfg->uplinkConfig)
3971         {
3972                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
3973                 return RFAILED;
3974         }
3975
3976    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
3977         {
3978                 DU_LOG("\nF1AP : BuildUlCfg failed");
3979                 return RFAILED;
3980         }
3981         srvCellCfg->supplementaryUplink = NULLP;
3982         srvCellCfg->pdcch_ServingCellConfig = NULLP;
3983
3984    srvCellCfg->pdsch_ServingCellConfig = NULLP;
3985         DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct     ServingCellConfig__pdsch_ServingCellConfig));
3986         if(!srvCellCfg->pdsch_ServingCellConfig)
3987         {
3988                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
3989                 return RFAILED;
3990         }
3991
3992    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
3993         {
3994                 DU_LOG("\nF1AP : BuildPdschSrvCellCfg failed");
3995                 return RFAILED;
3996         }
3997
3998    srvCellCfg->csi_MeasConfig = NULLP;
3999 #if 0
4000         DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct      ServingCellConfig__csi_MeasConfig))
4001         if(!srvCellCfg->csi_MeasConfig)
4002         {
4003                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4004                 return RFAILED;
4005         }
4006
4007    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4008         {
4009                 DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4010                 return RFAILED;
4011         }
4012 #endif
4013    srvCellCfg->sCellDeactivationTimer = NULLP;
4014         srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4015         srvCellCfg->tag_Id = TAG_ID;
4016    srvCellCfg->dummy = NULLP;
4017    srvCellCfg->pathlossReferenceLinking = NULLP;
4018    srvCellCfg->servingCellMO = NULLP;
4019    srvCellCfg->ext1 = NULLP;
4020
4021         return ROK;
4022 }
4023 /*******************************************************************
4024  *
4025  * @brief Builds Spcell config
4026  *
4027  * @details
4028  *
4029  *    Function : BuildSpCellCfg
4030  *
4031  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4032  *
4033  * @params[in] SpCellConfig_t spCellCfg
4034  *
4035  * @return ROK     - success
4036  *         RFAILED - failure
4037  *
4038  * ****************************************************************/
4039 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4040 {
4041
4042    spCellCfg->servCellIndex = NULLP;
4043         DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4044         if(!spCellCfg->servCellIndex)
4045         {
4046                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4047                 return RFAILED;
4048         }
4049    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4050
4051    spCellCfg->reconfigurationWithSync = NULLP;
4052         spCellCfg->rlf_TimersAndConstants = NULLP;
4053    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4054         DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4055         if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4056         {
4057                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4058                 return RFAILED;
4059         }
4060    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4061
4062    spCellCfg->spCellConfigDedicated = NULLP;
4063    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4064         if(!spCellCfg->spCellConfigDedicated)
4065         {
4066                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4067                 return RFAILED;
4068         }
4069    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4070         {
4071                 DU_LOG("\nF1AP : BuildSpCellCfgDed failed");
4072                 return RFAILED;
4073         }
4074         return ROK;
4075 }
4076 /*******************************************************************
4077 *
4078 * @brief Builds Phy cell group config
4079 *
4080 * @details
4081 *
4082 *    Function : BuildPhyCellGrpCfg
4083 *
4084 *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4085 *
4086 * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4087 *
4088 * @return ROK     - success
4089 *         RFAILED - failure
4090 *
4091 * ****************************************************************/
4092 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4093 {
4094    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4095         phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4096
4097    phyCellGrpCfg->p_NR_FR1 = NULLP;
4098         DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4099         if(!phyCellGrpCfg->p_NR_FR1)
4100         {
4101                 DU_LOG("\nF1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4102                 return RFAILED;
4103         }
4104    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4105         phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4106         phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4107         phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4108         phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4109         phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4110         phyCellGrpCfg->cs_RNTI = NULLP;
4111         phyCellGrpCfg->ext1 = NULLP;
4112         phyCellGrpCfg->ext2 = NULLP;
4113
4114         return ROK;
4115 }
4116 /*******************************************************************
4117 *
4118 * @brief Builds Mac cell group config
4119 *
4120 * @details
4121 *
4122 *    Function : BuildMacCellGrpCfg
4123 *
4124 *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4125 *
4126 * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4127 *
4128 * @return ROK     - success
4129 *         RFAILED - failure
4130 *
4131 * ****************************************************************/
4132 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4133 {
4134    macCellGrpCfg->drx_Config = NULLP;
4135    macCellGrpCfg->schedulingRequestConfig = NULLP;
4136         DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4137         if(!macCellGrpCfg->schedulingRequestConfig)
4138         {
4139                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4140                 return RFAILED;
4141         }
4142
4143         if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4144         {
4145            DU_LOG("\nF1AP : BuildSchedulingReqConfig failed");
4146                 return RFAILED;
4147         }
4148
4149    macCellGrpCfg->bsr_Config = NULLP;
4150    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4151         if(!macCellGrpCfg->bsr_Config)
4152         {
4153                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4154                 return RFAILED;
4155         }
4156
4157    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4158         {
4159       DU_LOG("\nF1AP : BuildBsrConfig failed");
4160            return RFAILED;
4161         }
4162
4163    macCellGrpCfg->tag_Config = NULLP;
4164    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4165         if(!macCellGrpCfg->tag_Config)
4166         {
4167                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4168                 return RFAILED;
4169         }
4170
4171    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4172         {
4173            DU_LOG("\nF1AP : BuildTagConfig failed");
4174            return RFAILED;
4175    }
4176
4177    macCellGrpCfg->phr_Config = NULLP;
4178    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4179         if(!macCellGrpCfg->phr_Config)
4180         {
4181                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4182                 return RFAILED;
4183         }
4184
4185    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4186         {
4187            DU_LOG("\nF1AP : BuildPhrConfig failed");
4188            return RFAILED;
4189    }
4190
4191    macCellGrpCfg->skipUplinkTxDynamic = false;
4192         macCellGrpCfg->ext1 = NULLP;
4193
4194         return ROK;
4195 }
4196  /*******************************************************************
4197  *
4198  * @brief Frees memeory allocated for SearchSpcToAddModList
4199  *
4200  * @details
4201  *
4202  *    Function : FreeSearchSpcToAddModList
4203  *
4204  *    Functionality: Deallocating memory of SearchSpcToAddModList
4205  *
4206  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4207  *
4208  * @return void
4209  *
4210  4221 * ****************************************************************/
4211 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4212 {
4213     uint8_t idx1=0;
4214     uint8_t idx2=0;
4215     struct  SearchSpace *searchSpc=NULLP;
4216
4217     if(searchSpcList->list.array)
4218          {
4219             if(searchSpcList->list.array[idx2])
4220             {
4221           searchSpc = searchSpcList->list.array[idx2];
4222                if(searchSpc->controlResourceSetId)
4223                {
4224                   if(searchSpc->monitoringSlotPeriodicityAndOffset)
4225                   {
4226                      if(searchSpc->monitoringSymbolsWithinSlot)
4227                      {
4228                         if(searchSpc->monitoringSymbolsWithinSlot->buf)
4229                         {
4230                            if(searchSpc->nrofCandidates)
4231                            {
4232                               if(searchSpc->searchSpaceType)
4233                               {
4234                                  DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4235                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4236                                  DU_FREE(searchSpc->searchSpaceType, sizeof(struct
4237                                                                          SearchSpace__searchSpaceType));
4238                               }
4239                               DU_FREE(searchSpc->nrofCandidates,
4240                               sizeof(struct SearchSpace__nrofCandidates));
4241                            }
4242                            DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4243                            searchSpc->monitoringSymbolsWithinSlot->size);
4244                         }
4245                         DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4246                         sizeof(BIT_STRING_t));
4247                      }
4248                      DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4249                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4250                   }
4251                   DU_FREE(searchSpc->controlResourceSetId,
4252                   sizeof(ControlResourceSetId_t));
4253                      }
4254                   }
4255                   for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4256              {
4257                  DU_FREE(searchSpcList->list.array[idx1],
4258                                 sizeof(struct SearchSpace));
4259                   }
4260                   DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4261          }
4262 }
4263  /*******************************************************************
4264  *
4265  * @brief Frees memory allocated for PdschTimeDomAllocList
4266  *
4267  * @details
4268  *
4269  *    Function : FreePdschTimeDomAllocList
4270  *
4271  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4272  *
4273  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4274  *
4275  * @return void
4276  *
4277  4221 * ****************************************************************/
4278 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4279 {
4280    uint8_t idx1=0;
4281
4282         if(timeDomAllocList->choice.setup)
4283    {
4284       if(timeDomAllocList->choice.setup->list.array)
4285       {
4286           for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4287           {
4288              DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4289              sizeof(struct PDSCH_TimeDomainResourceAllocation));
4290           }
4291           DU_FREE(timeDomAllocList->choice.setup->list.array, \
4292           timeDomAllocList->choice.setup->list.size);
4293       }
4294       DU_FREE(timeDomAllocList->choice.setup,\
4295       sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4296    }
4297 }
4298  /*******************************************************************
4299  *
4300  * @brief Frees memory allocated for PuschTimeDomAllocList
4301  *
4302  *@details
4303  *
4304  *    Function : FreePuschTimeDomAllocList
4305  *
4306  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4307  *
4308  * @params[in] PUSCH_Config_t *puschCfg
4309  *
4310  * @return void
4311  *
4312  4221 * ****************************************************************/
4313 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4314 {
4315     uint8_t idx1=0;
4316          uint8_t idx2=0;
4317     struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4318
4319     if(puschCfg->pusch_TimeDomainAllocationList)
4320     {
4321        timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4322        if(timeDomAllocList_t->choice.setup)
4323        {
4324           if(timeDomAllocList_t->choice.setup->list.array)
4325           {
4326              DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4327              for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4328              {
4329                 DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4330                                     sizeof(PUSCH_TimeDomainResourceAllocation_t));
4331                                  }
4332                                  DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4333              timeDomAllocList_t->choice.setup->list.size);
4334           }
4335           DU_FREE(timeDomAllocList_t->choice.setup, \
4336                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4337        }
4338                  DU_FREE(puschCfg->transformPrecoder, sizeof(long));
4339        DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4340                  sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4341     }
4342
4343 }
4344  /*******************************************************************
4345  *
4346  * @brief Frees memory allocated for InitialUlBWP
4347  *
4348  * @details
4349  *
4350  *    Function : FreeInitialUlBWP
4351  *
4352  *    Functionality: Deallocating memory of InitialUlBWP
4353  *
4354  * @params[in] BWP_UplinkDedicated_t *ulBwp
4355  *
4356  * @return void
4357  *
4358  * ****************************************************************/
4359 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4360 {
4361     uint8_t  rSetIdx, rsrcIdx;
4362     SRS_Config_t   *srsCfg = NULLP;
4363     PUSCH_Config_t *puschCfg = NULLP;
4364     struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
4365          struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
4366          struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
4367          struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
4368
4369          if(ulBwp->pusch_Config)
4370     {
4371        if(ulBwp->pusch_Config->choice.setup)
4372        {
4373           puschCfg=ulBwp->pusch_Config->choice.setup;
4374           if(puschCfg->dataScramblingIdentityPUSCH)
4375           {
4376              if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4377              {
4378                 FreePuschTimeDomAllocList(puschCfg);
4379                 dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
4380                                          if(dmrsUlCfg->choice.setup)
4381                 {
4382                    if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4383                    {
4384                       if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4385                       {
4386                          DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4387                                                                  sizeof(long));
4388                                                                  DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
4389                          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4390                                                          }
4391                                                          DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
4392                                                          sizeof(long));
4393                                                  }
4394                                                  DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
4395                 }
4396                                          DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4397                                          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4398                                  }
4399              DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4400           }
4401           DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4402             }
4403                  DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4404
4405                  /* Free SRS-Config */
4406                  if(ulBwp->srs_Config)
4407                  {
4408                     if(ulBwp->srs_Config->choice.setup)
4409                          {
4410                             srsCfg = ulBwp->srs_Config->choice.setup;
4411
4412                                  /* Free Resource Set to add/mod list */
4413                             if(srsCfg->srs_ResourceSetToAddModList)
4414                                  {
4415                                     rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
4416                                          if(rsrcSetList->list.array)
4417                                          {
4418                                             rSetIdx = 0;
4419
4420                                                  /* Free SRS resource Id list in this SRS resource set */
4421                                                  if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4422                                                  {
4423                                                     rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4424
4425                                                     if(rsrcIdList->list.array)
4426                                                          {
4427                                                             for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4428                                                                  {
4429                                                                     DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4430                                                             }
4431                                                             DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
4432                                                          }
4433                                                     DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4434                                                             sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4435                                                  }
4436
4437                                                  /* Free resource type info for this SRS resource set */
4438                                                  DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4439                                                     sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4440
4441                                                  /* Free memory for each resource set */
4442                                             for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4443                                                  {
4444                                                     DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4445                                                  }
4446                                             DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
4447                                          }
4448                                     DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
4449                                             sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4450                                  }
4451
4452                                  /* Free resource to add/modd list */
4453                                  if(srsCfg->srs_ResourceToAddModList)
4454                                  {
4455                                     resourceList = srsCfg->srs_ResourceToAddModList;
4456                                          if(resourceList->list.array)
4457                                          {
4458                                             rsrcIdx = 0;
4459                                                  DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
4460                                                     sizeof(struct SRS_Resource__transmissionComb__n2));
4461                                             DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
4462                                                     sizeof(struct SRS_Resource__resourceType__aperiodic));
4463
4464                                             for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4465                                                  {
4466                                                     DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4467                    }
4468                                             DU_FREE(resourceList->list.array, resourceList->list.size);
4469                                          }
4470                                     DU_FREE(srsCfg->srs_ResourceToAddModList, \
4471                                             sizeof(struct SRS_Config__srs_ResourceToAddModList));
4472                                  }
4473
4474                             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4475                          }
4476                     DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4477        }
4478          }
4479 }
4480  /*******************************************************************
4481  *
4482  * @brief Frees memory allocated for initialUplinkBWP
4483  *
4484  * @details
4485  *
4486  *    Function : FreeinitialUplinkBWP
4487  *
4488  *    Functionality: Deallocating memory of initialUplinkBWP
4489  *
4490  * @params[in] UplinkConfig_t *ulCfg
4491  *
4492  * @return void
4493  *
4494  *
4495  * ****************************************************************/
4496 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
4497 {
4498    BWP_UplinkDedicated_t *ulBwp=NULLP;
4499    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
4500
4501         if(ulCfg->initialUplinkBWP)
4502         {
4503            ulBwp=ulCfg->initialUplinkBWP;
4504            if(ulCfg->firstActiveUplinkBWP_Id)
4505            {
4506               if(ulCfg->pusch_ServingCellConfig)
4507               {
4508                  puschCfg=ulCfg->pusch_ServingCellConfig;
4509                  if(puschCfg->choice.setup)
4510                  {
4511                     if(puschCfg->choice.setup->ext1)
4512                     {
4513                         DU_FREE(puschCfg->choice.setup->ext1->\
4514                                                  processingType2Enabled,sizeof(BOOLEAN_t));
4515                         DU_FREE(puschCfg->choice.setup->ext1->\
4516                                                  maxMIMO_Layers,sizeof(long));
4517                                                  DU_FREE(puschCfg->choice.setup->ext1, \
4518                                                  sizeof(struct PUSCH_ServingCellConfig__ext1));
4519                                         }
4520                     DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4521                  }
4522                  DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4523               }
4524               DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4525            }
4526            FreeInitialUlBWP(ulBwp);
4527            DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4528         }
4529 }
4530  /*******************************************************************
4531  *
4532  * @brief Frees emmory allocated for BWPDlDedPdschCfg
4533  *
4534  * @details
4535  *
4536  *    Function : FreeBWPDlDedPdschCfg
4537  *
4538  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
4539  *
4540  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4541  *
4542  * @return void
4543  *
4544  *
4545  * ****************************************************************/
4546 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
4547 {
4548    struct PDSCH_Config *pdschCfg=NULLP;
4549         struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
4550    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
4551    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
4552
4553         if(dlBwp->pdsch_Config->choice.setup)
4554    {
4555       pdschCfg=dlBwp->pdsch_Config->choice.setup;
4556       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4557       {
4558           if(pdschCfg->pdsch_TimeDomainAllocationList)
4559           {
4560              timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
4561              if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
4562              {
4563                 prbBndlType=&pdschCfg->prb_BundlingType;
4564                 DU_FREE(prbBndlType->choice.staticBundling,\
4565                 sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4566                 DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4567              }
4568              FreePdschTimeDomAllocList(timeDomAllocList);
4569              DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
4570              sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4571           }
4572           dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
4573           if(dmrsDlCfg->choice.setup)
4574           {
4575              DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
4576              sizeof(long));
4577              DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
4578           }
4579           DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4580           sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4581        }
4582        DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4583     }
4584 }
4585  /*******************************************************************
4586  *
4587  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
4588  *
4589  * @details
4590  *
4591  *    Function : FreeBWPDlDedPdcchCfg
4592  *
4593  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
4594  *
4595  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4596  *
4597  * @return void
4598  *
4599  *
4600  * ****************************************************************/
4601 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
4602 {
4603    uint8_t idx1=0;
4604         uint8_t idx2=0;
4605         struct PDCCH_Config *pdcchCfg=NULLP;
4606    struct ControlResourceSet *controlRSet=NULLP;
4607         struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
4608
4609         if(dlBwp->pdcch_Config->choice.setup)
4610    {
4611       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
4612       if(pdcchCfg->controlResourceSetToAddModList)
4613       {
4614          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
4615          if(controlRSetList->list.array)
4616          {
4617             controlRSet = controlRSetList->list.array[idx2];
4618             if(controlRSet)
4619             {
4620                if(controlRSet->frequencyDomainResources.buf)
4621                {
4622                   if(controlRSet->pdcch_DMRS_ScramblingID)
4623                   {
4624                      if(pdcchCfg->searchSpacesToAddModList)
4625                      {
4626                          FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
4627                          DU_FREE(pdcchCfg->searchSpacesToAddModList, \
4628                          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
4629                      }
4630                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
4631                   }
4632                                                 DU_FREE(controlRSet->frequencyDomainResources.buf, \
4633                                                 controlRSet->frequencyDomainResources.size);
4634                                         }
4635                                 }
4636             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
4637             {
4638                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
4639             }
4640                                 DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
4641                         }
4642                         DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
4643                         sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
4644                 }
4645                 DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4646         }
4647 }
4648
4649 /*******************************************************************
4650  *
4651  * @brief Frees emmory allocated for DUToCURRCContainer
4652  *
4653  * @details
4654  *
4655  *    Function : FreeMemDuToCuRrcCont
4656  *
4657  *    Functionality: Deallocating memory of DuToCuRrcContainer
4658  *
4659  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
4660  *
4661  * @return ROK     - success
4662  *         RFAILED - failure
4663  *
4664 * ****************************************************************/
4665 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
4666 {
4667    uint8_t idx=0;
4668         SpCellConfig_t *spCellCfg=NULLP;
4669         ServingCellConfig_t *srvCellCfg=NULLP;
4670         BWP_DownlinkDedicated_t *dlBwp=NULLP;
4671         MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
4672         PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
4673         struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
4674         struct RLC_Config *rlcConfig=NULLP;
4675         struct LogicalChannelConfig *macLcConfig=NULLP;
4676         struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
4677         struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
4678         struct TAG_Config *tagConfig=NULLP;
4679         struct TAG_Config__tag_ToAddModList *tagList=NULLP;
4680         struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
4681         struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
4682
4683         rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
4684         if(rlcBearerList)
4685         {
4686                 if(rlcBearerList->list.array)
4687                 {
4688                         for(idx=0; idx<rlcBearerList->list.count; idx++)
4689                         {
4690                                 if(rlcBearerList->list.array[idx])
4691                                 {
4692                                    rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
4693                                    macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
4694                                    if(rlcConfig)
4695                                    {
4696                                       if(rlcConfig->choice.am)
4697                                            {
4698                                          DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
4699                                          DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
4700                                          DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
4701                                                 }
4702                                       DU_FREE(rlcConfig, sizeof(struct RLC_Config));
4703                }
4704                                    DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
4705                                 if(macLcConfig)
4706                                    {
4707                                       if(macLcConfig->ul_SpecificParameters)
4708                                            {
4709                                          DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,       sizeof(SchedulingRequestId_t));
4710                                          DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,       sizeof(long));
4711                                          DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
4712                                       }
4713                                       DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
4714                                    }
4715                                    DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
4716                                 }
4717                         }
4718                         DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
4719                 }
4720                 DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
4721         }
4722
4723         macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
4724         if(macCellGrpCfg)
4725         {
4726                 schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
4727       if(schedulingRequestConfig)
4728                 {
4729                    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
4730                         if(schReqList)
4731                         {
4732                            if(schReqList->list.array)
4733                                 {
4734                          for(idx=0;idx<schReqList->list.count; idx++)
4735                          {
4736                                            if(schReqList->list.array[idx])
4737                                                 {
4738                                     DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
4739                                     DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
4740                             }
4741                                         }
4742                          DU_FREE(schReqList->list.array, schReqList->list.size);
4743                                 }
4744                       DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
4745                                 sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
4746                    DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4747       }
4748                 if(macCellGrpCfg->bsr_Config)
4749                 {
4750                    DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4751                 }
4752                 tagConfig = macCellGrpCfg->tag_Config;
4753                 if(tagConfig)
4754                 {
4755                    tagList = tagConfig->tag_ToAddModList;
4756                         if(tagList)
4757                         {
4758                            if(tagList->list.array)
4759                                 {
4760                          for(idx=0; idx<tagList->list.count; idx++)
4761                          {
4762                    DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
4763                                         }
4764                          DU_FREE(tagList->list.array, tagList->list.size);
4765             }
4766                       DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
4767                         }
4768                    DU_FREE(tagConfig, sizeof(struct TAG_Config));
4769                 }
4770
4771                 phrConfig = macCellGrpCfg->phr_Config;
4772                 if(phrConfig)
4773                 {
4774                    DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
4775                    DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
4776       }
4777
4778                 DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
4779         }
4780
4781         phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
4782         if(phyCellGrpCfg)
4783         {
4784                 DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4785                 DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
4786         }
4787
4788         spCellCfg = cellGrpCfg->spCellConfig;
4789         if(spCellCfg)
4790         {
4791            if(spCellCfg->servCellIndex)
4792                 {
4793                    if(spCellCfg->rlmInSyncOutOfSyncThreshold)
4794                         {
4795                            if(spCellCfg->spCellConfigDedicated)
4796                                 {
4797                                    srvCellCfg = spCellCfg->spCellConfigDedicated;
4798                if(srvCellCfg->initialDownlinkBWP)
4799                                         {
4800                                            dlBwp = srvCellCfg->initialDownlinkBWP;
4801                                            if(srvCellCfg->firstActiveDownlinkBWP_Id)
4802                                                 {
4803                                                    if(srvCellCfg->defaultDownlinkBWP_Id)
4804                                                    {
4805                                                            if(srvCellCfg->uplinkConfig)
4806                                                                 {
4807                                                               if(srvCellCfg->pdsch_ServingCellConfig)
4808                                                                    {
4809                                                                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
4810                                                                             if(pdschCfg->choice.setup)
4811                                                                             {
4812                                                                                  DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
4813                                                                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4814                                                                                  }
4815                                                                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
4816                                                                                  ServingCellConfig__pdsch_ServingCellConfig));
4817                                                                          }
4818                                                                     FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
4819                                                                          DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4820                                                                 }
4821                                                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4822                                                         }
4823                                                    DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4824                                                 }
4825                   if(dlBwp->pdcch_Config)
4826                                            {
4827                                                     if(dlBwp->pdsch_Config)
4828                                                     {
4829                                                        FreeBWPDlDedPdschCfg(dlBwp);
4830                                                             DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4831                                                }
4832                                                     FreeBWPDlDedPdcchCfg(dlBwp);
4833                                                     DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4834                                            }
4835                                                 DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4836                                         }
4837                                         DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4838                                 }
4839                            DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4840                         }
4841                    DU_FREE(spCellCfg->servCellIndex, sizeof(long));
4842       }
4843                 DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
4844         }
4845         return ROK;
4846 }
4847 /*******************************************************************
4848  *
4849  * @brief Builds DU To CU RRC Container
4850  *
4851  * @details
4852  *
4853  *    Function : BuildDuToCuRrcContainer
4854  *
4855  *    Functionality: Builds DuToCuRrcContainer
4856  *
4857  * @params[in] idx, index in F1AP msg
4858  *             DuToCuRRCContainer, DuToCuRRCContainer
4859  *
4860  * @return ROK     - success
4861  *         RFAILED - failure
4862  *
4863  * ****************************************************************/
4864 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
4865 {
4866         CellGroupConfigRrc_t  cellGrpCfg;
4867         asn_enc_rval_t        encRetVal;
4868         uint8_t               ret = RFAILED;
4869
4870         while(1)
4871         {
4872                 cellGrpCfg.cellGroupId = CELL_GRP_ID;
4873
4874                 cellGrpCfg.rlc_BearerToAddModList = NULLP;
4875                 DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
4876                 if(!cellGrpCfg.rlc_BearerToAddModList)
4877                 {
4878                         DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
4879                         break;
4880                 }
4881                 if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
4882                 {
4883                         DU_LOG("\nF1AP : BuildRlcBearerToAddModList failed");
4884                         break;
4885                 }
4886
4887       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
4888                 cellGrpCfg.mac_CellGroupConfig = NULLP;
4889                 DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
4890                 if(!cellGrpCfg.mac_CellGroupConfig)
4891                 {
4892                         DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
4893                         break;
4894                 }
4895                 if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
4896                 {
4897                         DU_LOG("\nF1AP : BuildMacCellGrpCfg failed");
4898                         break;
4899                 }
4900
4901
4902                 cellGrpCfg.physicalCellGroupConfig = NULLP;
4903                 DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
4904                 if(!cellGrpCfg.physicalCellGroupConfig)
4905                 {
4906                         DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
4907                         break;
4908                 }
4909                 if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
4910                 {
4911                         DU_LOG("\nF1AP : BuildPhyCellGrpCfg failed");
4912                         break;
4913                 }
4914
4915                 cellGrpCfg.spCellConfig = NULLP;
4916                 DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
4917                 if(!cellGrpCfg.spCellConfig)
4918                 {
4919                         DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
4920                         break;
4921                 }
4922                 if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
4923                 {
4924                         DU_LOG("\nF1AP : BuildSpCellCfg failed");
4925                         break;
4926                 }
4927
4928       cellGrpCfg.sCellToAddModList = NULLP;
4929                 cellGrpCfg.sCellToReleaseList = NULLP;
4930                 cellGrpCfg.ext1 = NULLP;
4931
4932                 /* encode cellGrpCfg into duToCuRrcContainer */
4933                 xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
4934                 cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
4935                 encBufSize = 0;
4936                 encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
4937                 /* Encode results */
4938                 if(encRetVal.encoded == ENCODE_FAIL)
4939                 {
4940                         DU_LOG( "\n F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
4941                                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4942                         break;
4943                 }
4944                 else
4945                 {
4946                         DU_LOG("\n F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
4947                         for(int i=0; i< encBufSize; i++)
4948                         {
4949                                 printf("%x",encBuf[i]);
4950                         }
4951                 }
4952
4953            duToCuRrcContainer->size = encBufSize;
4954                 DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
4955                 if(!duToCuRrcContainer->buf)
4956                 {
4957          DU_LOG("\nF1AP : Memory allocation failed in BuildDuToCuRrcContainer");
4958                         break;
4959                 }
4960                 memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
4961                 ret = ROK;
4962                 break;
4963         }
4964    FreeMemDuToCuRrcCont(&cellGrpCfg);
4965         return ret;
4966 }
4967
4968 /*******************************************************************
4969  *
4970  * @brief Builds and sends the InitialULRRCMessage
4971  *
4972  * @details
4973  *
4974  *    Function : BuildAndSendInitialRrcMsgTransfer
4975  *
4976  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
4977  *                   it to the CU through SCTP.
4978  *
4979  * @params[in]
4980  *
4981  * @return ROK     - success
4982  *         RFAILED - failure
4983  *
4984  * ****************************************************************/
4985 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
4986                 uint8_t *rrcContainer)
4987 {
4988    uint8_t   ret;
4989         uint8_t   elementCnt;
4990    uint8_t   ieId;
4991         uint8_t   idx;
4992         uint8_t   idx1;
4993         F1AP_PDU_t  *f1apMsg = NULLP;
4994         InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
4995    asn_enc_rval_t                encRetVal;
4996         bool  checkvar=false;
4997         while(1)
4998         {
4999              DU_LOG("\n F1AP : Building RRC Setup Request\n");
5000                   DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5001                   if(f1apMsg == NULLP)
5002                   {
5003                       DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
5004                            break;
5005                   }
5006                   f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5007                   DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5008                   if(f1apMsg->choice.initiatingMessage == NULLP)
5009                   {
5010                      DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
5011                           break;
5012                   }
5013                   f1apMsg->choice.initiatingMessage->procedureCode =\
5014                          ProcedureCode_id_InitialULRRCMessageTransfer;
5015                   f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5016                   f1apMsg->choice.initiatingMessage->value.present = \
5017                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5018                   initULRRCMsg =\
5019                          &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5020         elementCnt = 5;
5021                   initULRRCMsg->protocolIEs.list.count = elementCnt;
5022                   initULRRCMsg->protocolIEs.list.size = \
5023                          elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5024                   /* Initialize the F1Setup members */
5025                    DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5026                    if(initULRRCMsg->protocolIEs.list.array == NULLP)
5027                    {
5028                       DU_LOG(" F1AP : Memory allocation for\
5029                                 RRCSetupRequestMessageTransferIEs failed");
5030                                 break;
5031                    }
5032                    for(idx=0; idx<elementCnt; idx++)
5033               {
5034                            DU_ALLOC(initULRRCMsg->protocolIEs.list.array[idx],\
5035                                  sizeof(InitialULRRCMessageTransferIEs_t));
5036                                  if(initULRRCMsg->protocolIEs.list.array[idx] == NULLP)
5037                                  {
5038                                      break;
5039                                  }
5040                    }
5041                    idx1 = 0;
5042                    /*GNB DU UE F1AP ID*/
5043                    initULRRCMsg->protocolIEs.list.array[idx1]->id  = \
5044                                       ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5045                         initULRRCMsg->protocolIEs.list.array[idx1]->criticality  = Criticality_reject;
5046                    initULRRCMsg->protocolIEs.list.array[idx1]->value.present = \
5047                                       InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5048                    initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5049
5050
5051                         /*NRCGI*/
5052                         idx1++;
5053                         initULRRCMsg->protocolIEs.list.array[idx1]->id  = \
5054                                  ProtocolIE_ID_id_NRCGI;
5055                         initULRRCMsg->protocolIEs.list.array[idx1]->criticality  =Criticality_reject;
5056                         initULRRCMsg->protocolIEs.list.array[idx1]->value.present = \
5057                        InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5058
5059                         ret =\
5060                         BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI);
5061               if(ret!=ROK)
5062                         {
5063                             break;
5064                         }
5065
5066                         /*CRNTI*/
5067                         idx1++;
5068                         initULRRCMsg->protocolIEs.list.array[idx1]->id  = \
5069                                        ProtocolIE_ID_id_C_RNTI;
5070                         initULRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
5071                         initULRRCMsg->protocolIEs.list.array[idx1]->value.present =\
5072                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
5073                         initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.C_RNTI = crnti;
5074
5075          /*RRCContainer*/
5076                         idx1++;
5077                         initULRRCMsg->protocolIEs.list.array[idx1]->id  = \
5078                                        ProtocolIE_ID_id_RRCContainer;
5079                         initULRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
5080                         initULRRCMsg->protocolIEs.list.array[idx1]->value.present =\
5081                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
5082
5083                         initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size =\
5084                                                       strlen((const char*)rrcContainer);
5085          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
5086                                         initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
5087                         if(!initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
5088                         {
5089                       DU_LOG(" F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
5090                                 break;
5091
5092                         }
5093          memcpy(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, rrcContainer,
5094                                         initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
5095
5096
5097                         /*DUtoCURRCContainer*/
5098                         idx1++;
5099                         initULRRCMsg->protocolIEs.list.array[idx1]->id  = \
5100                                        ProtocolIE_ID_id_DUtoCURRCContainer;
5101                         initULRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
5102                         initULRRCMsg->protocolIEs.list.array[idx1]->value.present =\
5103                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
5104
5105                         ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer);
5106          if(ret != ROK)
5107                         {
5108                            break;
5109                         }
5110
5111                         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5112
5113                         /* Encode the F1SetupRequest type as APER */
5114                         cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
5115                         encBufSize = 0;
5116                         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
5117                         /* Encode results */
5118                         if(encRetVal.encoded == ENCODE_FAIL)
5119                         {
5120                             DU_LOG( "\n F1AP : Could not encode Initial UL RRC Message Transfer\
5121                                     structure (at %s)\n",encRetVal.failed_type ? \
5122                                          encRetVal.failed_type->name : "unknown");
5123                                  break;
5124                         }
5125                         else
5126                         {
5127
5128                                   DU_LOG("\n F1AP : Created APER encoded buffer for Initial UL RRC\
5129                                   Message transfer\n");
5130                                    for(int i=0; i< encBufSize; i++)
5131                                         {
5132                                             printf("%x",encBuf[i]);
5133                                         }
5134                         }
5135                         /* Sending  msg  */
5136                         if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
5137                         {
5138                             DU_LOG("\n F1AP : Sending Initial UL RRC Message Transfer Failed");
5139                                  break;
5140                         }
5141                         checkvar=true;
5142                         break;
5143         }
5144
5145         if(f1apMsg != NULLP)
5146    {
5147             if(f1apMsg->choice.initiatingMessage != NULLP)
5148                  {
5149                      if(initULRRCMsg->protocolIEs.list.array != NULLP)
5150                           {
5151                          if(idx == elementCnt)
5152                               {
5153                                        idx1=1;
5154                                   if(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.pLMN_Identity.buf!=NULLP)
5155                                        {
5156                                            if(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.nRCellIdentity.buf!=NULLP)
5157                                                 {
5158                                                     DU_FREE(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.nRCellIdentity.buf,
5159                                                          initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.nRCellIdentity.size);
5160                                                 }
5161                                                 DU_FREE(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.pLMN_Identity.buf,\
5162                                                  initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.pLMN_Identity.size);
5163                                         }
5164
5165                                                   idx1=3;
5166                                                   if(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
5167                                                   {
5168                                                           DU_FREE(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
5169                                                                           initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
5170                                                   }
5171
5172                                                   idx1 = 4;
5173                                                   if(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer.buf)
5174                                                   {
5175                                                      DU_FREE(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer.buf,
5176                                                           initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer.size);
5177                                                   }
5178                                         for(ieId=0; ieId<elementCnt; ieId++)
5179                                         {
5180                                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieId],sizeof(InitialULRRCMessageTransferIEs_t));
5181                                         }
5182                                }
5183                                else
5184                                {
5185                                     for(ieId=0; ieId<idx; ieId++)
5186                                               {
5187                                                   DU_FREE(initULRRCMsg->protocolIEs.list.array[ieId],sizeof(InitialULRRCMessageTransferIEs_t));
5188                                               }
5189                                }
5190                                          DU_FREE(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5191                          }
5192                          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5193                  }
5194                  DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5195         }
5196         if(checkvar==true)
5197            return ROK;
5198         else
5199            return RFAILED;
5200 }/* End of BuildAndSendInitialRrcMsgTransfer*/
5201
5202 /*******************************************************************
5203  *
5204  * @brief Builds Special cell list for UE Setup Request
5205  *
5206  * @details
5207  *
5208  *    Function : BuildSplCellList
5209  *
5210  *    Functionality: Constructs the Special Cell list for UESetReq
5211  *
5212  * @params[in] SCell_ToBeSetup_List_t *spCellLst
5213  *
5214  * @return ROK     - success
5215  *         RFAILED - failure
5216  *
5217  * ****************************************************************/
5218 uint8_t BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
5219 {
5220         uint8_t  cellCnt;
5221         uint8_t  idx;
5222         uint8_t  ret;
5223         cellCnt = 1;
5224         spCellLst->list.count = cellCnt;
5225         spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
5226         DU_ALLOC(spCellLst->list.array,spCellLst->list.size);
5227         if(spCellLst->list.array == NULLP)
5228         {
5229                 return RFAILED;
5230         }
5231         for(idx=0; idx<cellCnt; idx++)
5232         {
5233                 DU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
5234                 if(spCellLst->list.array[idx] == NULLP)
5235                 {
5236                         return RFAILED;
5237                 }
5238         }
5239         idx = 0;
5240         spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
5241         spCellLst->list.array[idx]->criticality = Criticality_ignore;
5242         spCellLst->list.array[idx]->value.present =\
5243                 SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
5244         /* Special Cell ID -NRCGI */
5245         ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
5246         if(ret != ROK)
5247         {
5248                 return RFAILED;
5249         }
5250         /*Special Cell Index*/
5251         spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
5252   return ROK;
5253 }/* End of BuildSplCellList*/
5254
5255 /*******************************************************************
5256  *
5257  * @brief Builds SRBS to be setup
5258  *
5259  * @details
5260  *
5261  *    Function : BuildSRBSetup
5262  *
5263  *    Functionality: Constructs the SRB's for UESetReq
5264  *
5265  * @params[in] SRBs_ToBeSetup_List_t *srbSet
5266  *
5267  * @return ROK     - success
5268  *         RFAILED - failure
5269  *
5270  * ****************************************************************/
5271 uint8_t BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
5272 {
5273         uint8_t idx;
5274         uint8_t srbCnt;
5275         srbCnt = 1;
5276         srbSet->list.count = srbCnt;
5277         srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
5278         DU_ALLOC(srbSet->list.array,srbSet->list.size);
5279         if(srbSet->list.array == NULLP)
5280         {
5281                 return RFAILED;
5282         }
5283         for(idx=0; idx<srbCnt; idx++)
5284         {
5285                 DU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
5286                 if(srbSet->list.array[idx] == NULLP)
5287            {
5288                    return RFAILED;
5289                 }
5290         }
5291         idx = 0;
5292         srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
5293         srbSet->list.array[idx]->criticality = Criticality_ignore;
5294         srbSet->list.array[idx]->value.present = \
5295                         SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
5296    srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
5297    return ROK;
5298 }/* End of BuildSRBSetup*/
5299
5300 /*******************************************************************
5301  *
5302  * @brief Builds QOS Info for DRB Setum Item
5303  *
5304  * @details
5305  *
5306  *    Function : BuildQOSInfo
5307  *
5308  *    Functionality: Constructs the QOS Info for DRB Setup Item
5309  *
5310  * @params[in] QoSInformation_t *qosinfo
5311  *
5312  * @return ROK     - success
5313  *         RFAILED - failure
5314  *
5315  * ****************************************************************/
5316 uint8_t BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
5317 {
5318         /* NonDynamic5QIDescriptor */
5319         drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
5320         DU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
5321         if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
5322         {
5323                 return RFAILED;
5324         }
5325         /*FiveQI*/
5326         drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = 0;
5327         /*AveragingWindow*/
5328         DU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
5329                                                                                                 sizeof(AveragingWindow_t));
5330         if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
5331                                                                                                                                                                                                         NULLP)
5332         {
5333                 return RFAILED;
5334         }
5335         *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
5336         /*MaxDataBurstVolume*/
5337         DU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
5338                                                                                                 sizeof(MaxDataBurstVolume_t));
5339         if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
5340                                                                                                                                                                                                         NULLP)
5341         {
5342                 return RFAILED;
5343         }
5344         *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
5345
5346         /*nRGRAN Allocation Retention Priority*/
5347         drbQos->nGRANallocationRetentionPriority.priorityLevel =        \
5348                                                                                                 PriorityLevel_highest;
5349         drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = \
5350                                                         Pre_emptionCapability_may_trigger_pre_emption;
5351         drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = \
5352                                                                 Pre_emptionVulnerability_not_pre_emptable;
5353
5354         /* TO DO: GBR_QoSFlowInformation */
5355         return ROK;
5356 }/*End of BuildQOSInfo*/
5357
5358 /*******************************************************************
5359  *
5360  * @brief Builds SNSSAI
5361  *
5362  * @details
5363  *
5364  *    Function : BuildSNSSAI
5365  *
5366  *    Functionality: Constructs the SNSSAI For DRB list
5367  *
5368  * @params[in] SNSSAI_t *snssai
5369  *
5370  * @return ROK     - success
5371  *         RFAILED - failure
5372  *
5373  * ****************************************************************/
5374 uint8_t BuildSNSSAI(SNSSAI_t *snssai)
5375 {
5376         /*SNSSAI*/
5377           /*ssT*/
5378         snssai->sST.size = sizeof(uint8_t);
5379         DU_ALLOC(snssai->sST.buf,snssai->sST.size);
5380         if(snssai->sST.buf == NULLP)
5381         {
5382                 return RFAILED;
5383         }
5384         snssai->sST.buf[0] = 3;
5385           /*sD*/
5386         DU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
5387         if(snssai->sD == NULLP)
5388         {
5389                 return RFAILED;
5390         }
5391         snssai->sD->size = 3*sizeof(uint8_t);
5392         DU_ALLOC(snssai->sD->buf,snssai->sD->size);
5393         if(snssai->sD->buf == NULLP)
5394         {
5395                 return RFAILED;
5396         }
5397                 snssai->sD->buf[0] = 3;
5398                 snssai->sD->buf[1] = 6;
5399                 snssai->sD->buf[2] = 9;
5400    return ROK;
5401 }/*End of BuildSNSSAI*/
5402
5403 /*******************************************************************
5404  *
5405  * @brief Builds the flow map.
5406  *
5407  * @details
5408  *
5409  *    Function : BuildFlowsMap
5410  *
5411  *    Functionality: Constructs the flowmap For DRB list
5412  *
5413  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
5414  *
5415  * @return ROK     - success
5416  *         RFAILED - failure
5417  *
5418  * ****************************************************************/
5419 uint8_t BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap)
5420 {
5421         uint8_t  ret;
5422         uint8_t  idx;
5423         uint8_t  flowCnt;
5424         flowCnt = 1;
5425         flowMap->list.count = flowCnt;
5426         flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
5427         DU_ALLOC(flowMap->list.array,flowMap->list.size);
5428         if(flowMap->list.array == NULLP)
5429         {
5430                 return RFAILED;
5431         }
5432         for(idx=0; idx<flowCnt; idx++)
5433         {
5434                 DU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
5435                 if(flowMap->list.array[idx] == NULLP)
5436                 {
5437                    return RFAILED;
5438                 }
5439         }
5440         idx = 0;
5441         flowMap->list.array[idx]->qoSFlowIdentifier = 0;
5442         ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters);
5443         if(ret != ROK)
5444         {
5445                 return RFAILED;
5446         }
5447    return ROK;
5448 }/*End of BuildFlowsMap*/
5449
5450 /*******************************************************************
5451  *
5452  * @brief Builds the Uplink Tunnel Info
5453  *
5454  * @details
5455  *
5456  *    Function : BuildULTnlInfo
5457  *
5458  *    Functionality: Constructs the UL TnlInfo For DRB list
5459  *
5460  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
5461  *
5462  * @return ROK     - success
5463  *         RFAILED - failure
5464  *
5465  * ****************************************************************/
5466 uint8_t BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
5467 {
5468         uint8_t idx;
5469         uint8_t ulCnt;
5470         ulCnt = 1;
5471         ulInfo->list.count = ulCnt;
5472         ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
5473         DU_ALLOC(ulInfo->list.array,ulInfo->list.size);
5474         if(ulInfo->list.array == NULLP)
5475         {
5476                 return RFAILED;
5477         }
5478         for(idx=0; idx<ulCnt; idx++)
5479         {
5480                 DU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
5481                 if(ulInfo->list.array[idx] == NULLP)
5482                 {
5483                         return RFAILED;
5484                 }
5485         }
5486         idx = 0;
5487         ulInfo->list.array[idx]->uLUPTNLInformation.present = \
5488                                                                 UPTransportLayerInformation_PR_gTPTunnel;
5489         /*GTP TUNNEL*/
5490         DU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
5491                                 sizeof(GTPTunnel_t));
5492         if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
5493         {
5494                 return RFAILED;
5495         }
5496         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5497                 transportLayerAddress.size      = 4*sizeof(uint8_t);
5498    DU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5499                 transportLayerAddress.buf,ulInfo->list.array[idx]->\
5500                 uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
5501         if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5502                 transportLayerAddress.buf == NULLP)
5503         {
5504                 return RFAILED;
5505         }
5506         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5507                 transportLayerAddress.buf[0] = 4;
5508         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5509                 transportLayerAddress.buf[1] = 4;
5510         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5511                 transportLayerAddress.buf[2] = 4;
5512         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5513                 transportLayerAddress.buf[3] = 5;
5514         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5515                 transportLayerAddress.bits_unused = 0;
5516         /*GTP TEID*/
5517         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
5518                                         = 4 * sizeof(uint8_t);
5519         DU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5520                                 gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
5521                                 gTPTunnel->gTP_TEID.size);
5522         if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
5523                                 == NULLP)
5524         {
5525                 return RFAILED;
5526         }
5527         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5528                 gTP_TEID.buf[0] = 11;
5529         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5530                 gTP_TEID.buf[1] = 0;
5531         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5532                 gTP_TEID.buf[2] = 0;
5533         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5534                 gTP_TEID.buf[3] = 1;
5535
5536    return ROK;
5537 }/*End of BuildULTnlInfo*/
5538
5539 /*******************************************************************
5540  *
5541  * @brief Builds DRBS to be setup
5542  *
5543  * @details
5544  *
5545  *    Function : BuildDRBSetup
5546  *
5547  *    Functionality: Constructs the DRB's for UESetReq
5548  *
5549  * @params[in] DRBs_ToBeSetup_List_t *drbSet
5550  *
5551  * @return ROK     - success
5552  *         RFAILED - failure
5553  *
5554  * ****************************************************************/
5555 uint8_t BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
5556 {
5557         uint8_t BuildQOSInforet;
5558         uint8_t BuildSNSSAIret;
5559         uint8_t BuildFlowsMapret;
5560         uint8_t idx;
5561         uint8_t drbCnt;
5562         DRBs_ToBeSetup_Item_t *drbSetItem;
5563         drbCnt = 1;
5564         drbSet->list.count = drbCnt;
5565         drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
5566         DU_ALLOC(drbSet->list.array,drbSet->list.size);
5567         if(drbSet->list.array == NULLP)
5568         {
5569                 return RFAILED;
5570         }
5571         for(idx=0; idx<drbCnt; idx++)
5572         {
5573                 DU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
5574                 if(drbSet->list.array[idx] == NULLP)
5575                 {
5576                         return RFAILED;
5577                 }
5578         }
5579         idx = 0;
5580         drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
5581         drbSet->list.array[idx]->criticality = Criticality_ignore;
5582         drbSet->list.array[idx]->value.present = \
5583                         DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
5584    drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
5585         /*dRBID*/
5586         drbSetItem->dRBID = 1;
5587         /*qoSInformation*/
5588         drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
5589         DU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
5590         if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
5591         {
5592                 return RFAILED;
5593         }
5594         drbSetItem->qoSInformation.choice.choice_extension->id = \
5595                                                         ProtocolIE_ID_id_DRB_Information;
5596         drbSetItem->qoSInformation.choice.choice_extension->criticality = \
5597                                                         Criticality_ignore;
5598         drbSetItem->qoSInformation.choice.choice_extension->value.present = \
5599                                                         QoSInformation_ExtIEs__value_PR_DRB_Information;
5600         BuildQOSInforet = BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
5601                                                         choice_extension->value.choice.DRB_Information.dRB_QoS);
5602         if(BuildQOSInforet != ROK)
5603         {
5604                 return RFAILED;
5605         }
5606         /*SNSSAI*/
5607         BuildSNSSAIret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
5608                                                         choice_extension->value.choice.DRB_Information.sNSSAI);
5609         if(BuildSNSSAIret != ROK)
5610         {
5611                 return RFAILED;
5612         }
5613         /*Flows mapped to DRB List*/
5614         BuildFlowsMapret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
5615                                 choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List);
5616         if(BuildFlowsMapret != ROK)
5617         {
5618                 return RFAILED;
5619         }
5620         /*ULUPTNLInformation To Be Setup List*/
5621    BuildULTnlInforet = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
5622         if(BuildULTnlInforet != ROK)
5623         {
5624                 return RFAILED;
5625         }
5626         /*RLCMode*/
5627         drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
5628
5629         /*UL Configuration*/
5630         DU_ALLOC(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
5631         if(drbSetItem->uLConfiguration == NULLP)
5632         {
5633            return RFAILED;
5634         }
5635         drbSetItem->uLConfiguration->uLUEConfiguration = ULUEConfiguration_no_data;
5636         return ROK;
5637 }/* End of BuildDRBSetup*/
5638 /*******************************************************************
5639 *
5640 * @brief Deallocating memory of function BuildAndSendUESetReq
5641 *
5642 * @details
5643 *
5644 *    Function : FreeNrcgi
5645 *
5646 *    Functionality: Deallocating memory for function BuildNrcgi
5647 *
5648 * @params[in] NRCGI_t *nrcgi
5649 *
5650 * @return void
5651 *
5652 *******************************************************************/
5653 void FreeNrcgi(NRCGI_t *nrcgi)
5654 {
5655         if(nrcgi->pLMN_Identity.buf != NULLP)
5656         {
5657              if(nrcgi->nRCellIdentity.buf != NULLP)
5658              {
5659            DU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
5660                   }
5661              DU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
5662         }
5663 }
5664 /*******************************************************************
5665 *
5666 * @brief  Deallocating memory of function BuildAndSendUESetReq
5667 *
5668 * @details
5669 *
5670 *    Function : FreeSplCellList
5671 *
5672 *    Functionality: Deallocating memory for function BuildSplCellList
5673 *
5674 * @params[in] SCell_ToBeSetup_List_t *spCellLst
5675 *
5676 * @return void
5677 *
5678 *
5679 * *****************************************************************/
5680 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
5681 {
5682     uint8_t  cellidx;
5683     if(spCellLst->list.array != NULLP)
5684          {
5685               for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
5686                         {
5687                             if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
5688                                  {
5689                                     FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
5690                                  }
5691                                  if(spCellLst->list.array[cellidx]!=NULLP)
5692                                  {
5693                                      DU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
5694                                  }
5695                         }
5696                         DU_FREE(spCellLst->list.array,spCellLst->list.size);
5697          }
5698 }
5699  /*******************************************************************
5700  *
5701  * @brief Deallocating memory of function BuildAndSendUESetReq
5702  *
5703  * @details
5704  *
5705  *    Function : FreeSRBSetup
5706  *
5707  *    Functionality: Deallocating memory for function BuildSRBSetup
5708  *
5709  * @params[in] SRBs_ToBeSetup_List_t *srbSet
5710  *
5711  * @return void
5712  *
5713  *
5714  * ******************************************************************/
5715 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
5716 {
5717     uint8_t srbidx;
5718          if(srbSet->list.array != NULLP)
5719          {
5720              for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
5721                   {
5722                       if(srbSet->list.array[srbidx]!=NULLP)
5723                                 {
5724                                     DU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
5725                                 }
5726                   }
5727                   DU_FREE(srbSet->list.array,srbSet->list.size);
5728          }
5729 }
5730  /*******************************************************************
5731   *
5732   * @brief Deallocating memory of function BuildAndSendUESetReq
5733   *
5734   * @details
5735   *
5736   *    Function : FreeQOSInfo
5737   *
5738   *    Functionality:  Deallocating memory for function BuildQOSInfo
5739   *
5740   * @params[in] QoSFlowLevelQoSParameters_t *drbQos
5741   *
5742   * @return void
5743   *
5744   * ****************************************************************/
5745 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
5746 {
5747     if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
5748          {
5749              if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
5750                   {
5751                       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
5752                                 {
5753                                     DU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
5754                                          sizeof(MaxDataBurstVolume_t));
5755                                 }
5756                                  DU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
5757                                  sizeof(AveragingWindow_t));
5758                   }
5759                   DU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
5760                   sizeof(NonDynamic5QIDescriptor_t));
5761          }
5762 }
5763  /*******************************************************************
5764   *
5765   * @brief Deallocating memory of function BuildAndSendUESetReq
5766   *
5767   * @details
5768   *
5769   *    Function : FreeULTnlInfo
5770   *
5771   *    Functionality:  Deallocating memory for function BuildULTnlInfo
5772   *
5773   * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
5774   *
5775   * @return void
5776   *
5777
5778  * ****************************************************************/
5779 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
5780 {
5781     uint8_t ulidx=0;
5782          if(ulInfo->list.array != NULLP)
5783          {
5784              for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
5785                   {
5786                       if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
5787                                 {
5788                                     if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
5789                                          {
5790                                              if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
5791                                                   transportLayerAddress.buf != NULLP)
5792                                                   {
5793                                                       if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
5794                                                                 !=NULLP)
5795                                                                 {
5796                                                                      DU_ALLOC(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
5797                                                                           gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
5798                                                                           gTPTunnel->gTP_TEID.size);
5799                                                                 }
5800                                                                 DU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
5801                                                                 transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
5802                                                                 uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
5803                                                   }
5804                                                   DU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
5805                                                   sizeof(GTPTunnel_t));
5806                                          }
5807                                 }
5808                                 if(ulInfo->list.array[ulidx]!=NULLP)
5809                                 {
5810                                     DU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
5811                                 }
5812                   }
5813                   DU_FREE(ulInfo->list.array,ulInfo->list.size);
5814          }
5815 }
5816 /*******************************************************************
5817  *
5818  * @brief Deallocating memory for BuildAndSendUESetReq
5819  *
5820  * @details
5821  *
5822  *    Function : FreeDRBSetup
5823  *
5824  *    Functionality:  Deallocating memory for BuildDRBSetup
5825  *
5826  * @params[in] DRBs_ToBeSetup_List_t *drbSet
5827  *
5828  * @return void
5829  *
5830  * ****************************************************************/
5831 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
5832 {
5833     DRBs_ToBeSetup_Item_t *drbSetItem;
5834          uint8_t  flowidx;
5835          uint8_t  drbidx;
5836     if(drbSet->list.array == NULLP)
5837          {
5838              for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
5839                   {
5840                        if(drbidx==0&&drbSet->list.array[drbidx] != NULLP)
5841                                  {
5842                                     drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
5843                                     if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
5844                                          {
5845                                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5846                                                          qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
5847                                                          {
5848                                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5849                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
5850                                                                   {
5851                                                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5852                                                                                  qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
5853                                                                                  {
5854                                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
5855                                                                                           {
5856                                                                                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
5857                                                                                                         {
5858                                                                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
5859                                                                                                                  {
5860                                                                                                                       if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
5861                                                                                                                                 flows_Mapped_To_DRB_List.list.array != NULLP)
5862                                                                                                                                 {
5863                                                                                                                                     for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
5864                                                                                                                                          flows_Mapped_To_DRB_List.list.count; flowidx++)
5865                                                                                                                                          {
5866                                                                                                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5867                                                                                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
5868                                                                                                                                                   {
5869                                                                                                                                                       if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5870                                                                                                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5871                                                                                                                                                                  qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
5872                                                                                                                                                                 {
5873                                                                                                                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5874                                                                                                                                                                           DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5875                                                                                                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
5876                                                                                                                                                                           {
5877                                                                                                                                                                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5878                                                                                                                                                                                         DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5879                                                                                                                                                                                         qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
5880                                                                                                                                                                                    {
5881                                                                                                                                                                                                  if((BuildULTnlInforet==ROK)&&(drbSetItem->uLConfiguration!=NULLP))
5882                                                                                                                                                                                                  {
5883                                                                                                                                                                                                      DU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
5884                                                                                                                                                                                                  }
5885                                                                                                                                                                                                  FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
5886                                                                          DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5887                                                                                                                                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5888                                                                                                                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
5889                                                                                                                                                                                                  sizeof(MaxDataBurstVolume_t));
5890                                                                                                                                                                                    }
5891                                                                                                                                                                                         DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5892                                                                                                                                                                                         DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5893                                                                                                                                                                                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
5894                                                                                                                                                                           }
5895                                                                                                                                                                           DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5896                                                                                                                                                                           DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5897                                                                  qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
5898                                                                                                                                                                 }
5899                                                                                                                                                   }
5900                                                                                                                                                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5901                                                                                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
5902                                                                                                                                                   {
5903                                                                                                                                                       DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5904                                                                                                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
5905                                                                                                                                                   }
5906                                                                                                                                          }
5907                                                                                                                                     DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
5908                                                                                                                                          flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
5909                                                                                                                                          choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
5910                                                                                                                                 }
5911                                                                                                                       DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
5912                                                                                                                         drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
5913                                                                                                                  }
5914                                                                                                                  DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
5915                                                                                                                  sizeof(OCTET_STRING_t));
5916                                                                                                         }
5917                                                                                                          DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
5918                                                                                                          drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
5919                                                                                           }
5920                                                                                           DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5921                                                                                      qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
5922                                                                                  }
5923                                                                        DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5924                                                                                  qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
5925                                                                   }
5926                                                              DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5927                                                                   qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
5928                                                          }
5929                                                    DU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
5930                                          }
5931                                  }
5932                        if(drbSet->list.array[drbidx]!=NULLP)
5933                                  {
5934                                      DU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
5935                                 }
5936                   }
5937              DU_FREE(drbSet->list.array,drbSet->list.size);
5938          }
5939 }
5940 /*******************************************************************
5941  *
5942  * @brief Free the UE Setup Request
5943  *
5944  * @details
5945  *
5946  *    Function : FreeUESetReq
5947  *
5948  *    Functionality: Deallocate the memory of BuildUESetReq
5949  *
5950  * @params[in]  F1AP_PDU_t  *f1apMsg
5951  *
5952  * @return void
5953  *
5954  *
5955  * ****************************************************************/
5956  void FreeUESetReq(F1AP_PDU_t  *f1apMsg)
5957 {
5958     uint8_t idx=2;
5959     uint8_t ieId;
5960     UEContextSetupRequest_t       *ueSetReq;
5961
5962     if(f1apMsg != NULLP)
5963     {
5964                if(f1apMsg->choice.initiatingMessage != NULLP)
5965           {
5966                              ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
5967                    if(ueSetReq->protocolIEs.list.array != NULLP)
5968               {
5969                  if(ueSetReq->protocolIEs.list.array[idx])
5970                                           {
5971                                                if(Nrcgiret==ROK )
5972                       {
5973                                                               idx=6;
5974                                                               if(ueSetReq->protocolIEs.list.array[idx])
5975                                                                         {
5976                                 if(SplCellListret==ROK)
5977                                 {
5978                                                                                       idx++;
5979                                     if(ueSetReq->protocolIEs.list.array[idx])
5980                                                                                                 {
5981                                                                                                if(SRBSetupret == ROK)
5982                                         {
5983                                            idx=8;
5984                                                                                           FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
5985                                         }
5986                                         idx--;
5987                                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
5988                                                                                                 }
5989                                                                    }
5990                                 idx--;
5991                                 FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
5992                                                                         }
5993                       }
5994                       idx=2;
5995                       FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
5996                                                 }
5997                   for(ieId=0; ieId<ueSetReq->protocolIEs.list.count; ieId++)
5998                   {
5999                       if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
6000                       {
6001                            DU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
6002                        }
6003                   }
6004                    DU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
6005               }
6006               DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6007         }
6008         DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6009      }
6010  }
6011
6012 /*******************************************************************
6013  *
6014  * @brief Builds and sends the UE Setup Request
6015  *
6016  * @details
6017  *
6018  *    Function : BuildAndSendUESetReq
6019  *
6020  *    Functionality: Constructs the UE Setup Request and sends
6021  *                   it to the CU through SCTP.
6022  *
6023  * @params[in]
6024  *
6025  * @return ROK     - success
6026  *         RFAILED - failure
6027  *
6028  * ****************************************************************/
6029 uint8_t BuildAndSendUESetReq()
6030 {
6031
6032         uint8_t  elementCnt;
6033         uint8_t   idx;
6034         uint8_t   idx1;
6035         F1AP_PDU_t                                              *f1apMsg = NULL;
6036    UEContextSetupRequest_t                      *ueSetReq;
6037         asn_enc_rval_t                                          encRetVal;        /* Encoder return value */
6038    uint8_t ret= RFAILED;
6039         uint8_t ret1;
6040         while(1)
6041         {
6042             DU_LOG("\n F1AP : Building UE Context Setup Request\n");
6043
6044             DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6045             if(f1apMsg == NULLP)
6046             {
6047                     DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
6048                          break;
6049             }
6050
6051             f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6052             DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6053             if(f1apMsg->choice.initiatingMessage == NULLP)
6054             {
6055                      DU_LOG(" F1AP : Memory allocation for      F1AP-PDU failed");
6056                           break;
6057             }
6058
6059             f1apMsg->choice.initiatingMessage->procedureCode = \
6060                                                                                                         ProcedureCode_id_UEContextSetup;
6061             f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
6062             f1apMsg->choice.initiatingMessage->value.present = \
6063                                    InitiatingMessage__value_PR_UEContextSetupRequest;
6064             ueSetReq =
6065                   &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
6066             elementCnt = 9;
6067             ueSetReq->protocolIEs.list.count = elementCnt;
6068             ueSetReq->protocolIEs.list.size = \
6069                                                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *);
6070
6071             /* Initialize the UESetup members */
6072             DU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
6073
6074                  if(ueSetReq->protocolIEs.list.array == NULLP)
6075             {
6076                      DU_LOG(" F1AP : Memory allocation for UE Context SetupRequest failed");
6077                           break;
6078             }
6079
6080             for(idx1=0; idx1<elementCnt; idx1++)
6081             {
6082                      DU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
6083                      if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
6084                      {
6085                              break;
6086                      }
6087             }
6088
6089             idx = 0;
6090
6091             /*GNB CU UE F1AP ID*/
6092             ueSetReq->protocolIEs.list.array[idx]->id   = \
6093                                                                                  ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
6094          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_reject;
6095             ueSetReq->protocolIEs.list.array[idx]->value.present = \
6096                                                 UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
6097             ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
6098
6099             /*GNB DU UE F1AP ID*/
6100             idx++;
6101             ueSetReq->protocolIEs.list.array[idx]->id   = \
6102                                                                                  ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6103             ueSetReq->protocolIEs.list.array[idx]->criticality  =       Criticality_ignore;
6104             ueSetReq->protocolIEs.list.array[idx]->value.present = \
6105                                                 UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
6106             ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
6107
6108             /*Special Cell ID*/
6109             idx++;
6110             ueSetReq->protocolIEs.list.array[idx]->id   = \
6111                                                                                                          ProtocolIE_ID_id_SpCell_ID;
6112             ueSetReq->protocolIEs.list.array[idx]->criticality  =       Criticality_reject;
6113             ueSetReq->protocolIEs.list.array[idx]->value.present = \
6114                                                                 UEContextSetupRequestIEs__value_PR_NRCGI;
6115             Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
6116             if(Nrcgiret != ROK)
6117             {
6118                     break;
6119             }
6120
6121             /*Served Cell Index*/
6122             idx++;
6123             ueSetReq->protocolIEs.list.array[idx]->id   = \
6124                                                                                                  ProtocolIE_ID_id_ServCellIndex;
6125             ueSetReq->protocolIEs.list.array[idx]->criticality  =       Criticality_reject;
6126             ueSetReq->protocolIEs.list.array[idx]->value.present = \
6127                                                 UEContextSetupRequestIEs__value_PR_ServCellIndex;
6128             ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
6129             CELL_INDEX;
6130
6131             /*CellULConfigured*/
6132             idx++;
6133             ueSetReq->protocolIEs.list.array[idx]->id   = \
6134                                                                                         ProtocolIE_ID_id_SpCellULConfigured;
6135             ueSetReq->protocolIEs.list.array[idx]->criticality  =       Criticality_ignore;
6136             ueSetReq->protocolIEs.list.array[idx]->value.present = \
6137                                                                         UEContextSetupRequestIEs__value_PR_CellULConfigured;
6138             ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
6139                                                                                                                                                         CellULConfigured_none;
6140
6141
6142              /*CUtoDURRCContainer*/
6143              idx++;
6144              ueSetReq->protocolIEs.list.array[idx]->id  = \
6145                                                                                                   ProtocolIE_ID_id_CUtoDURRCInformation;
6146              ueSetReq->protocolIEs.list.array[idx]->criticality =       Criticality_reject;
6147              ueSetReq->protocolIEs.list.array[idx]->value.present = \
6148                                                 UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
6149
6150              /*Special Cells to be SetupList*/
6151              idx++;
6152              ueSetReq->protocolIEs.list.array[idx]->id  = \
6153                                                                                                   ProtocolIE_ID_id_SCell_ToBeSetup_List;
6154              ueSetReq->protocolIEs.list.array[idx]->criticality =       Criticality_ignore;
6155              ueSetReq->protocolIEs.list.array[idx]->value.present = \
6156                                                 UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
6157              SplCellListret = BuildSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
6158              if(SplCellListret != ROK)
6159              {
6160                      break;
6161              }
6162              /*SRBs To Be Setup List*/
6163              idx++;
6164              ueSetReq->protocolIEs.list.array[idx]->id  = \
6165                                                                                  ProtocolIE_ID_id_SRBs_ToBeSetup_List;
6166              ueSetReq->protocolIEs.list.array[idx]->criticality =       Criticality_reject;
6167              ueSetReq->protocolIEs.list.array[idx]->value.present = \
6168                                                 UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
6169              SRBSetupret =      BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
6170              if(SRBSetupret != ROK)
6171              {
6172                      break;
6173              }
6174              /*DRBs to Be Setup List*/
6175              idx++;
6176              ueSetReq->protocolIEs.list.array[idx]->id  = \
6177                                                                                  ProtocolIE_ID_id_DRBs_ToBeSetup_List;
6178              ueSetReq->protocolIEs.list.array[idx]->criticality =       Criticality_reject;
6179              ueSetReq->protocolIEs.list.array[idx]->value.present = \
6180                                                 UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
6181              ret1 = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
6182              if(ret1 != ROK)
6183              {
6184                      break;
6185              }
6186
6187              xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6188
6189              /* Encode the F1SetupRequest type as APER */
6190              cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6191              encBufSize = 0;
6192              encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
6193                         encBuf);
6194              /* Encode results */
6195              if(encRetVal.encoded == ENCODE_FAIL)
6196              {
6197                 DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
6198                                 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6199                       break;
6200              }
6201              else
6202              {
6203                       DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
6204                       for(int i=0; i< encBufSize; i++)
6205                       {
6206                         printf("%x",encBuf[i]);
6207                       }
6208             }
6209
6210             /* Sending  msg  */
6211             if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL)   !=      ROK)
6212             {
6213                 DU_LOG("\n F1AP : Sending       UE Context Setup Request Failed");
6214                       break;
6215             }
6216                  ret = ROK;
6217                  break;
6218    }
6219         FreeUESetReq(f1apMsg);
6220
6221         return ret;
6222 }/* End of BuildAndSendUESetReq*/
6223
6224 /*******************************************************************
6225 *
6226 * @brief Handles received F1AP message and sends back response
6227 *
6228 * @details
6229 *
6230 *    Function : F1APMsgHdlr
6231 *
6232 *    Functionality:
6233 *         - Decodes received F1AP control message
6234 *         - Prepares response message, encodes and sends to SCTP
6235 *
6236 * @params[in]
6237 * @return ROK     - success
6238 *         RFAILED - failure
6239 *
6240 * ****************************************************************/
6241 void F1APMsgHdlr(Buffer *mBuf)
6242 {
6243    int i;
6244    char *recvBuf;
6245    MsgLen copyCnt;
6246    MsgLen recvBufLen;
6247    F1AP_PDU_t *f1apMsg;
6248    asn_dec_rval_t rval; /* Decoder return value */
6249    F1AP_PDU_t f1apasnmsg ;
6250
6251    DU_LOG("\nF1AP : Received F1AP message buffer");
6252    SPrntMsg(mBuf, 0,0);
6253
6254    /* Copy mBuf into char array to decode it */
6255    SFndLenMsg(mBuf, &recvBufLen);
6256    if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK)
6257    {
6258       DU_LOG("\nF1AP : Memory allocation failed");
6259       return;
6260    }
6261    if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
6262    {
6263       DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
6264       return;
6265    }
6266
6267    printf("\nF1AP : Received flat buffer to be decoded : ");
6268    for(i=0; i< recvBufLen; i++)
6269    {
6270         printf("%x",recvBuf[i]);
6271    }
6272
6273    /* Decoding flat buffer into F1AP messsage */
6274    f1apMsg = &f1apasnmsg;
6275    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
6276
6277    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
6278    SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen);
6279    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
6280    {
6281       DU_LOG("\nF1AP : ASN decode failed");
6282       return;
6283    }
6284    printf("\n");
6285    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6286
6287    switch(f1apMsg->present)
6288    {
6289       case F1AP_PDU_PR_successfulOutcome:
6290       {
6291          switch(f1apMsg->choice.successfulOutcome->value.present)
6292          {
6293             case SuccessfulOutcome__value_PR_F1SetupResponse:
6294             {
6295 #ifndef ODU_TEST_STUB
6296                procF1SetupRsp(f1apMsg);
6297 #endif
6298                break;
6299             }
6300
6301             case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
6302             {
6303                procGNBDUCfgUpdAck(f1apMsg);
6304                break;
6305             }
6306
6307             default:
6308             {
6309                DU_LOG("\nF1AP : Invalid type of successful outcome [%d]", f1apMsg->choice.successfulOutcome->value.present);
6310                return;
6311             }
6312          }/* End of switch(successfulOutcome) */
6313          break;
6314       }
6315                 case F1AP_PDU_PR_initiatingMessage:
6316                 {
6317                         switch(f1apMsg->choice.initiatingMessage->value.present)
6318                         {
6319                                 case InitiatingMessage__value_PR_DLRRCMessageTransfer:
6320                                         {
6321                                                 procDlRrcMsgTrans(f1apMsg);
6322                                                 break;
6323                                         }
6324
6325                                 default:
6326                                         {
6327                                                 DU_LOG("\nF1AP : Invalid type of initiating message[%d]",
6328                                                                 f1apMsg->choice.initiatingMessage->value.present);
6329                                                 return;
6330                                         }
6331                         }/* End of switch(initiatingMessage) */
6332                         break;
6333                 }
6334
6335       default:
6336       {
6337          DU_LOG("\nF1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
6338          return;
6339       }
6340
6341    }/* End of switch(f1apMsg->present) */
6342
6343 } /* End of F1APMsgHdlr */
6344
6345 /**********************************************************************
6346   End of file
6347  **********************************************************************/