src/du_app/du_f1ap_msg_hdl.c

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