src/du_app/du_f1ap_msg_hdl.c

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