src/du_app/du_f1ap_msg_hdl.c

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