src/du_app/du_f1ap_msg_hdl.c

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