src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "du_app_mac_inf.h"
  26 #include "du_cfg.h"
  27 #include "du_app_rlc_inf.h"
  28 #include "E2AP-PDU.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "GNB-DU-System-Information.h"
  32 #include "CellGroupConfigRrc.h"
  33 #include "MAC-CellGroupConfig.h"
  34 #include "SchedulingRequestConfig.h"
  35 #include "SchedulingRequestToAddMod.h"
  36 #include "BSR-Config.h"
  37 #include "TAG-Config.h"
  38 #include "TAG.h"
  39 #include "PHR-Config.h"
  40 #include "RLC-Config.h"
  41 #include "UL-AM-RLC.h"
  42 #include "DL-AM-RLC.h"
  43 #include "LogicalChannelConfig.h"
  44 #include "RLC-BearerConfig.h"
  45 #include "PhysicalCellGroupConfig.h"
  46 #include "SpCellConfig.h"
  47 #include "ServingCellConfig.h"
  48 #include "ControlResourceSet.h"
  49 #include "SearchSpace.h"
  50 #include "PDCCH-Config.h"
  51 #include "PDSCH-TimeDomainResourceAllocation.h"
  52 #include "PDSCH-TimeDomainResourceAllocationList.h"
  53 #include "DMRS-DownlinkConfig.h"
  54 #include "PDSCH-Config.h"
  55 #include "BWP-DownlinkDedicated.h"
  56 #include "PUSCH-TimeDomainResourceAllocation.h"
  57 #include "PUSCH-TimeDomainResourceAllocationList.h"
  58 #include "DMRS-UplinkConfig.h"
  59 #include "PUSCH-Config.h"
  60 #include "SRS-ResourceId.h"
  61 #include "SRS-Resource.h"
  62 #include "SRS-ResourceSet.h"
  63 #include "SRS-Config.h"
  64 #include "BWP-UplinkDedicated.h"
  65 #include "PUSCH-ServingCellConfig.h"
  66 #include "UplinkConfig.h"
  67 #include "PDSCH-ServingCellConfig.h"
  68 #include "DUtoCURRCContainer.h"
  69 #include<ProtocolIE-Field.h>
  70 #include "ProtocolExtensionField.h"
  71 #include "F1AP-PDU.h"
  72 #include "odu_common_codec.h"
  73 #include "du_mgr.h"
  74 #include "du_f1ap_msg_hdl.h"
  75
  76 uint8_t 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 uint8_t 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(ODU_GET_MSG(region, pool, &mBuf) == ROK)
 690    {
 691       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 692       {
 693          ODU_PRINT_MSG(mBuf, 0,0);
 694
 695          if(sctpSend(mBuf, F1_INTERFACE) != ROK)
 696          {
 697             DU_LOG("\nF1AP : SCTP Send failed");
 698             ODU_PUT_MSG(mBuf);
 699             return RFAILED;
 700          }
 701       }
 702       else
 703       {
 704          DU_LOG("\nF1AP : ODU_ADD_POST_MSG_MULT failed");
 705          ODU_PUT_MSG(mBuf);
 706          return RFAILED;
 707       }
 708       ODU_PUT_MSG(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       memset((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(true);
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(true)
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        memset((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                          if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
1939                             ULRRCMessageTransferIEs__value_PR_RRCContainer)
1940                          {
1941                             DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
1942                                ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
1943                          }
1944                          DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
1945                      }
1946                  }
1947                  DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
1948              }
1949              DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1950          }
1951          DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1952       }
1953 }
1954 /*******************************************************************
1955  *
1956  * @brief Builds and sends the ULRRCMessageTransfer
1957  *
1958  * @details
1959  *
1960  *    Function : BuildAndSendULRRCMessageTransfer
1961  *
1962  *    Functionality: Constructs the UL RRC Message Transfer and sends
1963  *                   it to the CU through SCTP.
1964  *
1965  * @params[in]
1966  *
1967  * @return ROK     - success
1968  *         RFAILED - failure
1969  *
1970  * ****************************************************************/
1971 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
1972     uint16_t msgLen, uint8_t *rrcMsg)
1973 {
1974    uint8_t   elementCnt;
1975    uint8_t   idx1;
1976    uint8_t   idx;
1977    F1AP_PDU_t                   *f1apMsg = NULL;
1978    ULRRCMessageTransfer_t       *ulRRCMsg;
1979    asn_enc_rval_t               encRetVal;        /* Encoder return value */
1980    uint8_t ret =RFAILED;
1981    while(true)
1982    {
1983       DU_LOG("\n F1AP : Building UL RRC Message Transfer Message\n");
1984
1985       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1986       if(f1apMsg == NULLP)
1987       {
1988          DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
1989          break;
1990       }
1991
1992       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1993       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1994       if(f1apMsg->choice.initiatingMessage == NULLP)
1995       {
1996          DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
1997          break;
1998       }
1999       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2000       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2001       f1apMsg->choice.initiatingMessage->value.present = \
2002         InitiatingMessage__value_PR_ULRRCMessageTransfer;
2003       ulRRCMsg =
2004          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2005       elementCnt = 4;
2006       ulRRCMsg->protocolIEs.list.count = elementCnt;
2007       ulRRCMsg->protocolIEs.list.size = \
2008         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2009
2010       /* Initialize the F1Setup members */
2011       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2012       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2013       {
2014          DU_LOG(" F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2015          break;
2016       }
2017       for(idx=0; idx<elementCnt; idx++)
2018       {
2019          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2020          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2021          {
2022             break;
2023          }
2024       }
2025
2026       idx1 = 0;
2027
2028       /*GNB CU UE F1AP ID*/
2029       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2030       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2031       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2032         ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2033       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2034
2035       /*GNB DU UE F1AP ID*/
2036       idx1++;
2037       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2038       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2039       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2040          ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2041       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2042
2043       /*SRBID*/
2044       idx1++;
2045       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2046       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2047       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2048         ULRRCMessageTransferIEs__value_PR_SRBID;
2049       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2050
2051       /*RRCContainer*/
2052       idx1++;
2053       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2054       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2055       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2056          ULRRCMessageTransferIEs__value_PR_RRCContainer;
2057       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2058       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2059          ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2060       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2061       {
2062          DU_LOG(" F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2063          break;
2064       }
2065       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2066          rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2067
2068       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2069
2070       /* Encode the F1SetupRequest type as APER */
2071       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2072       encBufSize = 0;
2073       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2074             encBuf);
2075       /* Encode results */
2076       if(encRetVal.encoded == ENCODE_FAIL)
2077       {
2078          DU_LOG( "\n F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2079                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2080          break;
2081       }
2082       else
2083       {
2084          DU_LOG("\n F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2085          for(int i=0; i< encBufSize; i++)
2086          {
2087             printf("%x",encBuf[i]);
2088          }
2089       }
2090
2091       /* Sending  msg  */
2092       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) !=      ROK)
2093       {
2094          DU_LOG("\n F1AP : Sending      UL RRC Message Transfer Failed");
2095          break;
2096       }
2097       ret = ROK;
2098       break;
2099    }
2100    FreeULRRCMessageTransfer(f1apMsg);
2101
2102         return ret;
2103 }/* End of BuildAndSendULRRCMessageTransfer*/
2104
2105 /*******************************************************************
2106 *
2107 * @brief Builds tag config
2108 *
2109 * @details
2110 *
2111 *    Function : BuildTagConfig
2112 *
2113 *    Functionality: Builds tag config in MacCellGroupConfig
2114 *
2115 * @params[in] TAG_Config *tag_Config
2116 *
2117 * @return ROK     - success
2118 *         RFAILED - failure
2119 *
2120 * ****************************************************************/
2121 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2122 {
2123         struct TAG_Config__tag_ToAddModList *tagList;
2124    uint8_t                     idx, elementCnt;
2125
2126    tagConfig->tag_ToReleaseList = NULLP;
2127    tagConfig->tag_ToAddModList = NULLP;
2128    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2129         if(!tagConfig->tag_ToAddModList)
2130         {
2131                 DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
2132                 return RFAILED;
2133         }
2134
2135         elementCnt = 1; //ODU_VALUE_ONE;
2136         tagList = tagConfig->tag_ToAddModList;
2137         tagList->list.count = elementCnt;
2138         tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2139
2140    tagList->list.array = NULLP;
2141         DU_ALLOC(tagList->list.array, tagList->list.size);
2142         if(!tagList->list.array)
2143         {
2144                 DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
2145                 return RFAILED;
2146         }
2147
2148         for(idx=0; idx<tagList->list.count; idx++)
2149         {
2150            tagList->list.array[idx] = NULLP;
2151                 DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2152                 if(!tagList->list.array[idx])
2153                 {
2154                         DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
2155                         return RFAILED;
2156                 }
2157         }
2158
2159         idx = 0;
2160         tagList->list.array[idx]->tag_Id = TAG_ID;
2161         tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2162
2163    return ROK;
2164 }
2165
2166 /*******************************************************************
2167 *
2168 * @brief Builds PHR Config
2169 *
2170 * @details
2171 *
2172 *    Function : BuildPhrConfig
2173 *
2174 *    Functionality: Builds phrConfig in MacCellGroupConfig
2175 *
2176 * @params[in] PHR Config *
2177 *
2178 * @return ROK     - success
2179 *         RFAILED - failure
2180 *
2181 * ****************************************************************/
2182 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2183 {
2184
2185    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2186         phrConfig->choice.setup = NULLP;
2187         DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2188         if(!phrConfig->choice.setup)
2189         {
2190                 DU_LOG("\nF1AP : Memory allocation failure in BuildPhrConfig");
2191                 return RFAILED;
2192         }
2193
2194         phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2195         phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2196    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2197         phrConfig->choice.setup->multiplePHR              = false;
2198         phrConfig->choice.setup->dummy                    = false;
2199         phrConfig->choice.setup->phr_Type2OtherCell       = false;
2200         phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2201
2202         return ROK;
2203 }
2204
2205 /*******************************************************************
2206 *
2207 * @brief Builds BSR Config
2208 *
2209 * @details
2210 *
2211 *    Function : BuildBsrConfig
2212 *
2213 *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2214 *
2215 * @params[in] BSR_Config *bsrConfig
2216 *
2217 * @return ROK     - success
2218 *         RFAILED - failure
2219 *
2220 * ****************************************************************/
2221 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2222 {
2223    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2224         bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2225         bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2226
2227    return ROK;
2228 }
2229
2230 /*******************************************************************
2231 *
2232 * @brief Builds scheduling request config
2233 *
2234 * @details
2235 *
2236 *    Function : BuildSchedulingReqConfig
2237 *
2238 *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2239 *
2240 * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2241 *
2242 * @return ROK     - success
2243 *         RFAILED - failure
2244 *
2245 * ****************************************************************/
2246 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
2247 {
2248         struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2249    uint8_t                     idx, elementCnt;
2250
2251    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2252         DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2253                         sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2254         if(!schedulingRequestConfig->schedulingRequestToAddModList)
2255         {
2256                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2257                 return RFAILED;
2258         }
2259
2260         elementCnt = 1; //ODU_VALUE_ONE;
2261         schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2262         schReqList->list.count = elementCnt;
2263    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2264
2265    schReqList->list.array = NULLP;
2266    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2267         if(!schReqList->list.array)
2268         {
2269                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2270                 return RFAILED;
2271         }
2272
2273    for(idx=0;idx<schReqList->list.count; idx++)
2274         {
2275            schReqList->list.array[idx] = NULLP;
2276                 DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2277                 if(!schReqList->list.array[idx])
2278                 {
2279                         DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2280                         return RFAILED;
2281                 }
2282         }
2283
2284         idx = 0;
2285         schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2286
2287    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2288         DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2289         if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2290         {
2291                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2292                 return RFAILED;
2293         }
2294    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2295         schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2296         schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2297
2298         return ROK;
2299 }
2300
2301 /*******************************************************************
2302 *
2303 * @brief Builds RLC Config
2304 *
2305 * @details
2306 *
2307 *    Function : BuildRlcConfig
2308 *
2309 *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
2310 *
2311 * @params[in] RLC_Config *rlcConfig
2312 *
2313 * @return ROK     - success
2314 *         RFAILED - failure
2315 *
2316 * ****************************************************************/
2317 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
2318 {
2319
2320    rlcConfig->present = RLC_Config_PR_am;
2321
2322    rlcConfig->choice.am = NULLP;
2323    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2324         if(!rlcConfig->choice.am)
2325         {
2326                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
2327                 return RFAILED;
2328         }
2329
2330    /* UL */
2331         rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2332    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2333         if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2334         {
2335                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
2336                 return RFAILED;
2337         }
2338    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2339         rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2340         rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2341         rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2342         rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2343
2344    /* DL */
2345    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2346    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2347         if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2348         {
2349                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
2350                 return RFAILED;
2351         }
2352         *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2353    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
2354         rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
2355
2356    return ROK;
2357 }
2358
2359 /*******************************************************************
2360 *
2361 * @brief Builds MAC LC Config
2362 *
2363 * @details
2364 *
2365 *    Function : BuildMacLCConfig
2366 *
2367 *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
2368 *
2369 * @params[in] struct LogicalChannelConfig macLcConfig
2370 *
2371 * @return ROK     - success
2372 *         RFAILED - failure
2373 *
2374 * ****************************************************************/
2375 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
2376 {
2377
2378    macLcConfig->ul_SpecificParameters = NULLP;
2379    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
2380         if(!macLcConfig->ul_SpecificParameters)
2381         {
2382                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
2383                 return RFAILED;
2384         }
2385
2386    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
2387         macLcConfig->ul_SpecificParameters->prioritisedBitRate =        PRIORTISIED_BIT_RATE;
2388         macLcConfig->ul_SpecificParameters->bucketSizeDuration =        BUCKET_SIZE_DURATION;
2389    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
2390         macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
2391         macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
2392    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
2393
2394    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
2395    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
2396    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
2397         {
2398                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
2399                 return RFAILED;
2400         }
2401    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
2402
2403    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
2404         DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,       sizeof(SchedulingRequestId_t));
2405         if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
2406         {
2407                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
2408                 return RFAILED;
2409         }
2410    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
2411
2412         macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
2413         macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
2414         macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
2415
2416    return ROK;
2417 }
2418
2419 /*******************************************************************
2420 *
2421 * @brief Builds RLC Bearer to Add/Mod list
2422 *
2423 * @details
2424 *
2425 *    Function :BuildRlcBearerToAddModList
2426 *
2427 *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
2428 *
2429 * @params[in] rlc_BearerToAddModList
2430 *
2431 * @return ROK     - success
2432 *         RFAILED - failure
2433 *
2434 * ****************************************************************/
2435 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
2436 {
2437    uint8_t                     idx, elementCnt;
2438
2439    elementCnt = 1;
2440    rlcBearerList->list.count = elementCnt;
2441         rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
2442
2443    rlcBearerList->list.array = NULLP;
2444         DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
2445         if(!rlcBearerList->list.array)
2446         {
2447                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2448                 return RFAILED;
2449         }
2450
2451    for(idx=0; idx<rlcBearerList->list.count; idx++)
2452         {
2453            rlcBearerList->list.array[idx] = NULLP;
2454                 DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
2455                 if(!rlcBearerList->list.array[idx])
2456                 {
2457                         DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2458                         return RFAILED;
2459                 }
2460         }
2461
2462    idx = 0;
2463         rlcBearerList->list.array[idx]->logicalChannelIdentity = RLC_LCID;
2464
2465         DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
2466         if(!rlcBearerList->list.array[idx]->servedRadioBearer)
2467         {
2468                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2469                 return RFAILED;
2470         }
2471
2472         rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
2473    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB_ID_1;
2474
2475    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
2476    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
2477    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
2478         if(!rlcBearerList->list.array[idx]->rlc_Config)
2479         {
2480                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2481                 return RFAILED;
2482         }
2483
2484    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
2485         {
2486                 DU_LOG("\nF1AP : BuildRlcConfig failed");
2487                 return RFAILED;
2488         }
2489
2490    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
2491    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
2492         if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
2493         {
2494                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2495                 return RFAILED;
2496         }
2497
2498         if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
2499         {
2500                 DU_LOG("\nF1AP : BuildMacLCConfig failed");
2501                 return RFAILED;
2502         }
2503
2504         return ROK;
2505 }
2506
2507 /*******************************************************************
2508  *
2509  * @brief Build Control resource set to add/modify list
2510  *
2511  * @details
2512  *
2513  *    Function : BuildControlRSetToAddModList
2514  *
2515  *    Functionality: Build Control resource set to add/modify list
2516  *
2517  * @params[in]
2518  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2519  *
2520  * @return ROK     - success
2521  *         RFAILED - failure
2522  *
2523  * ****************************************************************/
2524 uint8_t BuildControlRSetToAddModList
2525 (
2526 struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2527 )
2528 {
2529    uint8_t idx;
2530    uint8_t elementCnt;
2531    uint8_t numBytes, bitsUnused;
2532    struct ControlResourceSet *controlRSet;
2533    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
2534    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
2535
2536
2537    elementCnt = 1;
2538    controlRSetList->list.count = elementCnt;
2539    controlRSetList->list.size = \
2540        elementCnt * sizeof(struct ControlResourceSet *);
2541
2542    controlRSetList->list.array = NULLP;
2543    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
2544    if(!controlRSetList->list.array)
2545    {
2546       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2547       return RFAILED;
2548    }
2549
2550    for(idx = 0; idx < elementCnt; idx++)
2551    {
2552       controlRSetList->list.array[idx] = NULLP;
2553       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
2554       if(!controlRSetList->list.array[idx])
2555       {
2556          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2557          return RFAILED;
2558       }
2559    }
2560
2561    idx=0;
2562    controlRSet = controlRSetList->list.array[idx];
2563
2564    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
2565
2566         /* Values taken from reference logs :
2567          * size 6 bytes
2568          * 3 LSBs unsued
2569          * Bit string stored ff0000000000
2570          */
2571    numBytes = 6;
2572    bitsUnused = 3;
2573    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
2574
2575    controlRSet->frequencyDomainResources.buf = NULLP;
2576         DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
2577            controlRSet->frequencyDomainResources.size);
2578         if(!controlRSet->frequencyDomainResources.buf)
2579         {
2580            DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2581                 return RFAILED;
2582    }
2583
2584    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
2585    coreset0EndPrb = CORESET0_END_PRB;
2586    coreset1StartPrb = coreset0EndPrb + 6;
2587    coreset1NumPrb = CORESET1_NUM_PRB;
2588    /* calculate the PRBs */
2589    schAllocFreqDomRscType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
2590    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
2591    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
2592
2593    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
2594    controlRSet->cce_REG_MappingType.present = \
2595       ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
2596
2597    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
2598    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
2599         controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
2600         controlRSet->tci_PresentInDCI = NULLP;
2601 #if 0
2602    uint8_t tciStateIdx;
2603
2604    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
2605       sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
2606    if(!controlRset->tci_StatesPDCCH_ToAddList)
2607    {
2608       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2609       return RFAILED;
2610    }
2611
2612    elementCnt = 1;
2613    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
2614    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
2615    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
2616       controlRset->tci_StatesPDCCH_ToAddList->list.size)
2617    if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
2618    {
2619       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2620       return RFAILED;
2621    }
2622
2623    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
2624    {
2625       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
2626       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
2627       {
2628          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2629          return RFAILED;
2630       }
2631    }
2632
2633    tciStateIdx = 0;
2634    /* TODO */
2635    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
2636
2637    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
2638    if(!controlRset->tci_PresentInDCI)
2639    {
2640       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2641       return RFAILED;
2642    }
2643    /* TODO */
2644    *(controlRset->tci_PresentInDCI);
2645 #endif
2646
2647    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
2648    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
2649    if(!controlRSet->pdcch_DMRS_ScramblingID)
2650    {
2651       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2652       return RFAILED;
2653    }
2654    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
2655
2656    return ROK;
2657 } /* End BuildControlRSetToAddModList */
2658
2659 /*******************************************************************
2660  *
2661  * @brief Build search space to add/modify list
2662  *
2663  * @details
2664  *
2665  *    Function : BuildSearchSpcToAddModList
2666  *
2667  *    Functionality: Build search space to add/modify list
2668  *
2669  * @params[in]
2670  * @return ROK     - success
2671  *         RFAILED - failure
2672  *
2673  * ****************************************************************/
2674 uint8_t BuildSearchSpcToAddModList
2675 (
2676 struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
2677 )
2678 {
2679    uint8_t idx;
2680         uint8_t numBytes;
2681         uint8_t byteIdx;
2682         uint8_t bitsUnused;
2683    uint8_t elementCnt;
2684    struct SearchSpace *searchSpc;
2685
2686    elementCnt = 1;
2687    searchSpcList->list.count = elementCnt;
2688    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
2689
2690         searchSpcList->list.array = NULLP;
2691    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
2692    if(!searchSpcList->list.array)
2693    {
2694       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2695       return RFAILED;
2696    }
2697
2698    for(idx = 0; idx < elementCnt; idx++)
2699    {
2700            searchSpcList->list.array[idx] = NULLP;
2701       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
2702       if(!searchSpcList->list.array[idx])
2703       {
2704          DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2705          return RFAILED;
2706       }
2707    }
2708
2709    idx = 0;
2710    searchSpc = searchSpcList->list.array[idx];
2711
2712    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
2713
2714    searchSpc->controlResourceSetId = NULLP;
2715    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
2716    if(!searchSpc->controlResourceSetId)
2717    {
2718       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2719       return RFAILED;
2720    }
2721    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
2722
2723    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
2724    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
2725       sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
2726    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
2727         {
2728            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2729                 return RFAILED;
2730         }
2731    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
2732            SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
2733
2734    searchSpc->duration = NULLP;
2735    searchSpc->monitoringSymbolsWithinSlot = NULLP;
2736         DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
2737         if(!searchSpc->monitoringSymbolsWithinSlot)
2738         {
2739            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2740                 return RFAILED;
2741         }
2742
2743         /* Values taken from reference logs :
2744          * size 2 bytes
2745          * 2 LSBs unsued
2746          * Bit string stores 8000
2747          */
2748    numBytes = 2;
2749         bitsUnused = 2;
2750
2751    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
2752         searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
2753         DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
2754            searchSpc->monitoringSymbolsWithinSlot->size);
2755         if(!searchSpc->monitoringSymbolsWithinSlot->buf)
2756         {
2757            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2758                 return RFAILED;
2759         }
2760
2761         byteIdx = 0;
2762         searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
2763          PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
2764         searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
2765         searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
2766
2767    searchSpc->nrofCandidates = NULLP;
2768    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
2769    if(!searchSpc->nrofCandidates)
2770    {
2771       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2772       return RFAILED;
2773    }
2774
2775    searchSpc->nrofCandidates->aggregationLevel1 = \
2776            PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
2777    searchSpc->nrofCandidates->aggregationLevel2 = \
2778            PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
2779    searchSpc->nrofCandidates->aggregationLevel4 = \
2780            PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
2781    searchSpc->nrofCandidates->aggregationLevel8 = \
2782            PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
2783    searchSpc->nrofCandidates->aggregationLevel16 = \
2784            PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
2785
2786    searchSpc->searchSpaceType = NULLP;
2787    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
2788    if(!searchSpc->searchSpaceType)
2789    {
2790       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2791       return RFAILED;
2792    }
2793
2794    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
2795
2796    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
2797    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
2798       sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
2799    if(!searchSpc->searchSpaceType->choice.ue_Specific)
2800    {
2801       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2802       return RFAILED;
2803    }
2804    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
2805            PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
2806
2807    return ROK;
2808 }/* End BuildSearchSpcToAddModList */
2809
2810 /*******************************************************************
2811  *
2812  * @brief Builds BWP DL dedicated PDCCH config
2813  *
2814  * @details
2815  *
2816  *    Function : BuildBWPDlDedPdcchCfg
2817  *
2818  *    Functionality: Builds BWP DL dedicated PDCCH config
2819  *
2820  * @params[in] struct PDCCH_Config *pdcchCfg
2821  *
2822  * @return ROK     - success
2823  *         RFAILED - failure
2824  *
2825  * ****************************************************************/
2826 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
2827 {
2828    pdcchCfg->controlResourceSetToAddModList = NULLP;
2829    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
2830       sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
2831    if(!pdcchCfg->controlResourceSetToAddModList)
2832    {
2833       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
2834       return RFAILED;
2835    }
2836
2837         if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
2838         {
2839            return RFAILED;
2840         }
2841
2842    pdcchCfg->controlResourceSetToReleaseList = NULLP;
2843
2844    pdcchCfg->searchSpacesToAddModList = NULLP;
2845         DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
2846            sizeof(struct PDCCH_Config__searchSpacesToAddModList));
2847         if(!pdcchCfg->searchSpacesToAddModList)
2848         {
2849            DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
2850                 return RFAILED;
2851         }
2852
2853         if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
2854         {
2855            return RFAILED;
2856         }
2857
2858    pdcchCfg->searchSpacesToReleaseList = NULLP;
2859         pdcchCfg->downlinkPreemption = NULLP;
2860         pdcchCfg->tpc_PUSCH = NULLP;
2861         pdcchCfg->tpc_PUCCH = NULLP;
2862         pdcchCfg->tpc_SRS = NULLP;
2863
2864    return ROK;
2865 }
2866
2867 /*******************************************************************
2868  *
2869  * @brief Builds DMRS DL PDSCH Mapping type A
2870  *
2871  * @details
2872  *
2873  *    Function : BuildDMRSDLPdschMapTypeA
2874  *
2875  *    Functionality: Builds DMRS DL PDSCH Mapping type A
2876  *
2877  * @params[in]
2878  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
2879  * @return ROK     - success
2880  *         RFAILED - failure
2881  *
2882  * ****************************************************************/
2883 uint8_t BuildDMRSDLPdschMapTypeA
2884 (
2885 struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
2886 )
2887 {
2888    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
2889         dmrsDlCfg->choice.setup = NULLP;
2890    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
2891    if(!dmrsDlCfg->choice.setup)
2892    {
2893       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
2894       return RFAILED;
2895    }
2896
2897         dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
2898         dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
2899    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
2900    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
2901    {
2902       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
2903       return RFAILED;
2904    }
2905    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
2906
2907         dmrsDlCfg->choice.setup->maxLength = NULLP;
2908         dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
2909         dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
2910         dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
2911
2912    return ROK;
2913 }
2914
2915 /*******************************************************************
2916  *
2917  * @brief Builds TCI states to add/modify list
2918  *
2919  * @details
2920  *
2921  *    Function : BuildTCIStatesToAddModList
2922  *
2923  *    Functionality:Builds TCI states to add/modify list
2924  *
2925  * @params[in]
2926  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
2927  *
2928  * @return ROK     - success
2929  *         RFAILED - failure
2930  *
2931  * ****************************************************************/
2932 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
2933 {
2934    return ROK;
2935 }
2936
2937 /*******************************************************************
2938  *
2939  * @brief Builds PDSCH time domain allocation list
2940  *
2941  * @details
2942  *
2943  *    Function : BuildPdschTimeDomAllocList
2944  *
2945  *    Functionality: Builds PDSCH time domain allocation list
2946  *
2947  * @params[in]
2948  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
2949  *
2950  * @return ROK     - success
2951  *         RFAILED - failure
2952  *
2953  * ****************************************************************/
2954 uint8_t BuildPdschTimeDomAllocList
2955 (
2956 struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
2957 )
2958 {
2959    uint8_t idx;
2960    uint8_t elementCnt;
2961         struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
2962
2963    timeDomAllocList->present = \
2964            PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
2965
2966    timeDomAllocList->choice.setup = NULLP;
2967    DU_ALLOC(timeDomAllocList->choice.setup, \
2968            sizeof(struct PDSCH_TimeDomainResourceAllocationList));
2969    if(!timeDomAllocList->choice.setup)
2970         {
2971            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
2972                 return RFAILED;
2973         }
2974
2975         elementCnt = 1;
2976         timeDomAllocList->choice.setup->list.count = elementCnt;
2977         timeDomAllocList->choice.setup->list.size = \
2978            elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
2979
2980         timeDomAllocList->choice.setup->list.array = NULLP;
2981         DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
2982            timeDomAllocList->choice.setup->list.size);
2983         if(!timeDomAllocList->choice.setup->list.array)
2984         {
2985            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
2986                 return RFAILED;
2987         }
2988
2989         for(idx = 0; idx < elementCnt; idx++)
2990         {
2991            timeDomAllocList->choice.setup->list.array[idx] = NULLP;
2992            DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
2993                    sizeof(struct PDSCH_TimeDomainResourceAllocation));
2994                 if(!timeDomAllocList->choice.setup->list.array[idx])
2995                 {
2996                    DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
2997                         return RFAILED;
2998                 }
2999         }
3000
3001         idx = 0;
3002         timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3003
3004    timeDomAlloc->k0 = NULLP;
3005         timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3006         timeDomAlloc->startSymbolAndLength = \
3007            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3008
3009    return ROK;
3010 }
3011
3012 /*******************************************************************
3013  *
3014  * @brief Builds PDSCH PRB Bundling type
3015  *
3016  * @details
3017  *
3018  *    Function : BuildPdschPrbBundlingType
3019  *
3020  *    Functionality: Builds PDSCH PRB Bundling type
3021  *
3022  * @params[in]
3023  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3024  *
3025  * @return ROK     - success
3026  *         RFAILED - failure
3027  *
3028  * ****************************************************************/
3029 uint8_t BuildPdschPrbBundlingType
3030 (
3031 struct PDSCH_Config__prb_BundlingType *prbBndlType
3032 )
3033 {
3034    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3035
3036    prbBndlType->choice.staticBundling = NULLP;
3037         DU_ALLOC(prbBndlType->choice.staticBundling, \
3038            sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3039         if(!prbBndlType->choice.staticBundling)
3040         {
3041            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3042                 return RFAILED;
3043         }
3044         prbBndlType->choice.staticBundling->bundleSize = NULLP;
3045
3046    return ROK;
3047 }
3048
3049 /*******************************************************************
3050  *
3051  * @brief Builds BWP DL dedicated PDSCH config
3052  *
3053  * @details
3054  *
3055  *    Function : BuildBWPDlDedPdschCfg
3056  *
3057  *    Functionality: Builds BWP DL dedicated PDSCH config
3058  *
3059  * @params[in] struct PDSCH_Config *pdschCfg
3060  *
3061  * @return ROK     - success
3062  *         RFAILED - failure
3063  *
3064  * ****************************************************************/
3065 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3066 {
3067    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3068
3069    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3070    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3071       sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3072    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3073    {
3074       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3075       return RFAILED;
3076    }
3077
3078    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3079    {
3080       return RFAILED;
3081    }
3082
3083    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3084    pdschCfg->tci_StatesToAddModList = NULLP;
3085    pdschCfg->tci_StatesToReleaseList = NULLP;
3086         pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3087 #if 0
3088    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3089    if(!pdschCfg->tci_StatesToAddModList)
3090    {
3091       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3092       return RFAILED;
3093    }
3094    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3095    {
3096       return RFAILED;
3097    }
3098 #endif
3099
3100         pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3101
3102    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3103         DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3104            sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3105    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3106         {
3107       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3108                 return RFAILED;
3109         }
3110
3111         if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3112         {
3113            return RFAILED;
3114         }
3115
3116    pdschCfg->pdsch_AggregationFactor = NULLP;
3117         pdschCfg->rateMatchPatternToAddModList = NULLP;
3118         pdschCfg->rateMatchPatternToReleaseList = NULLP;
3119         pdschCfg->rateMatchPatternGroup1 = NULLP;
3120         pdschCfg->rateMatchPatternGroup2 = NULLP;
3121         pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3122         pdschCfg->mcs_Table = NULLP;
3123
3124         pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3125         DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3126         if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3127         {
3128            DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3129                 return RFAILED;
3130         }
3131         *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3132
3133         if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3134         {
3135            return RFAILED;
3136         }
3137
3138         pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3139         pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3140         pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3141         pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3142         pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3143         pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3144    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3145
3146    return ROK;
3147 }
3148
3149 /*******************************************************************
3150  *
3151  * @brief Builds intitial DL BWP
3152  * @details
3153  *
3154  *    Function : BuildInitialDlBWP
3155  *
3156  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3157  *
3158  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3159  *
3160  * @return ROK     - success
3161  *         RFAILED - failure
3162  *
3163  * ****************************************************************/
3164 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3165 {
3166    dlBwp->pdcch_Config = NULLP;
3167    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3168         if(!dlBwp->pdcch_Config)
3169         {
3170            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3171       return RFAILED;
3172         }
3173         dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3174
3175    dlBwp->pdcch_Config->choice.setup = NULLP;
3176         DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3177    if(!dlBwp->pdcch_Config->choice.setup)
3178    {
3179            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3180                 return RFAILED;
3181         }
3182    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3183         {
3184            return RFAILED;
3185         }
3186
3187    dlBwp->pdsch_Config = NULLP;
3188         DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3189         if(!dlBwp->pdsch_Config)
3190         {
3191            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3192                 return RFAILED;
3193         }
3194         dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3195
3196    dlBwp->pdsch_Config->choice.setup = NULLP;
3197    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3198    if(!dlBwp->pdsch_Config->choice.setup)
3199    {
3200       DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3201                 return RFAILED;
3202         }
3203
3204    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3205         {
3206            return RFAILED;
3207         }
3208
3209    dlBwp->sps_Config = NULLP;
3210    dlBwp->radioLinkMonitoringConfig = NULLP;
3211    return ROK;
3212 }
3213
3214 /*******************************************************************
3215  *
3216  * @brief Builds DMRS UL Pusch Mapping type A
3217  *
3218  * @details
3219  *
3220  *    Function : BuildDMRSULPuschMapTypeA
3221  *
3222  *    Functionality: Builds DMRS UL Pusch Mapping type A
3223  *
3224  * @params[in]
3225  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3226  * @return ROK     - success
3227  *         RFAILED - failure
3228  *
3229  * ****************************************************************/
3230 uint8_t BuildDMRSULPuschMapTypeA
3231 (
3232 struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3233 )
3234 {
3235    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3236    dmrsUlCfg->choice.setup= NULLP;
3237    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3238    if(!dmrsUlCfg->choice.setup)
3239    {
3240       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3241       return RFAILED;
3242    }
3243
3244    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3245         dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3246    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3247    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3248    {
3249       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3250       return RFAILED;
3251    }
3252    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3253
3254         dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3255         dmrsUlCfg->choice.setup->maxLength = NULLP;
3256    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3257    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3258       sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3259    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3260    {
3261       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3262       return RFAILED;
3263    }
3264
3265    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3266    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3267       sizeof(long));
3268    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3269    {
3270       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3271       return RFAILED;
3272    }
3273    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3274
3275         dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3276         dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3277    return ROK;
3278 }
3279
3280 /*******************************************************************
3281  *
3282  * @brief Build PUSCH time domain allocation list
3283  *
3284  * @details
3285  *
3286  *    Function : BuildPuschTimeDomAllocList
3287  *
3288  *    Functionality: Build PUSCH time domain allocation list
3289  *
3290  * @params[in]
3291  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3292  *
3293  * @return ROK     - success
3294  *         RFAILED - failure
3295  *
3296  * ****************************************************************/
3297 uint8_t BuildPuschTimeDomAllocList
3298 (
3299 struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3300 )
3301 {
3302    uint8_t idx;
3303    uint8_t elementCnt;
3304    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3305
3306    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3307    timeDomAllocList->choice.setup = NULLP;
3308    DU_ALLOC(timeDomAllocList->choice.setup, \
3309       sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3310    if(!timeDomAllocList->choice.setup)
3311    {
3312       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3313       return RFAILED;
3314    }
3315
3316    elementCnt = 1;
3317    timeDomAllocList->choice.setup->list.count = elementCnt;
3318    timeDomAllocList->choice.setup->list.size = \
3319       elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3320         timeDomAllocList->choice.setup->list.array = NULLP;
3321    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3322       timeDomAllocList->choice.setup->list.size);
3323    if(!timeDomAllocList->choice.setup->list.array)
3324    {
3325       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3326       return RFAILED;
3327    }
3328
3329    for(idx = 0; idx < elementCnt; idx++)
3330    {
3331            timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3332       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3333          sizeof(PUSCH_TimeDomainResourceAllocation_t));
3334       if(!timeDomAllocList->choice.setup->list.array[idx])
3335       {
3336          DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3337          return RFAILED;
3338       }
3339    }
3340
3341    idx = 0;
3342    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3343    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
3344    if(!timeDomAlloc->k2)
3345    {
3346       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3347       return RFAILED;
3348    }
3349    *(timeDomAlloc->k2) = PUSCH_K2;
3350    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3351    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
3352    return ROK;
3353 }
3354
3355 /*******************************************************************
3356  *
3357  * @brief Builds BWP UL dedicated PUSCH Config
3358  *
3359  * @details
3360  *
3361  *    Function : BuildBWPUlDedPuschCfg
3362  *
3363  *    Functionality:
3364  *      Builds BWP UL dedicated PUSCH Config
3365  *
3366  * @params[in] : PUSCH_Config_t *puschCfg
3367  *
3368  * @return ROK     - success
3369  *         RFAILED - failure
3370  *
3371  * ****************************************************************/
3372 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3373 {
3374    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3375    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3376    if(!puschCfg->dataScramblingIdentityPUSCH)
3377    {
3378       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3379       return RFAILED;
3380    }
3381    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3382
3383    puschCfg->txConfig = NULLP;
3384         puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3385    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3386       sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3387    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3388    {
3389       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3390       return RFAILED;
3391    }
3392
3393    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
3394    {
3395       return RFAILED;
3396    }
3397
3398    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
3399         puschCfg->pusch_PowerControl = NULLP;
3400         puschCfg->frequencyHopping = NULLP;
3401         puschCfg->frequencyHoppingOffsetLists = NULLP;
3402    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
3403
3404    puschCfg->pusch_TimeDomainAllocationList = NULLP;
3405    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
3406       sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
3407    if(!puschCfg->pusch_TimeDomainAllocationList)
3408    {
3409       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3410       return RFAILED;
3411    }
3412
3413    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
3414    {
3415       return RFAILED;
3416    }
3417
3418    puschCfg->pusch_AggregationFactor = NULLP;
3419         puschCfg->mcs_Table = NULLP;
3420         puschCfg->mcs_TableTransformPrecoder = NULLP;
3421    puschCfg->transformPrecoder = NULLP;
3422    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
3423    if(!puschCfg->transformPrecoder)
3424    {
3425       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3426       return RFAILED;
3427    }
3428    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
3429
3430         puschCfg->codebookSubset = NULLP;
3431         puschCfg->maxRank = NULLP;
3432         puschCfg->rbg_Size = NULLP;
3433         puschCfg->uci_OnPUSCH = NULLP;
3434         puschCfg->tp_pi2BPSK = NULLP;
3435
3436    return ROK;
3437 }
3438
3439 /*******************************************************************
3440  *
3441  * @brief Fills SRS resource to add/modify list
3442  *
3443  * @details
3444  *
3445  *    Function : BuildSrsRsrcAddModList
3446  *
3447  *    Functionality: Fills SRS resource to add/modify list
3448  *
3449  * @params[in]
3450  * @return ROK     - success
3451  *         RFAILED - failure
3452  *
3453  * ****************************************************************/
3454 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
3455 {
3456    uint8_t   elementCnt;
3457    uint8_t   rsrcIdx;
3458
3459    elementCnt = 1;
3460    resourceList->list.count = elementCnt;
3461    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
3462    resourceList->list.array = NULLP;
3463    DU_ALLOC(resourceList->list.array, resourceList->list.size);
3464    if(!resourceList->list.array)
3465    {
3466       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3467       return RFAILED;
3468    }
3469
3470    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
3471    {
3472       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
3473       if(!resourceList->list.array[rsrcIdx])
3474       {
3475          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3476          return RFAILED;
3477       }
3478    }
3479
3480    rsrcIdx = 0;
3481    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
3482    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
3483    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
3484
3485    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
3486    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
3487       sizeof(struct SRS_Resource__transmissionComb__n2));
3488    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
3489    {
3490       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3491       return RFAILED;
3492    }
3493    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
3494            = SRS_COMB_OFFSET_N2;
3495    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
3496            = SRS_CYCLIC_SHIFT_N2;
3497
3498    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
3499            PUSCH_START_SYMBOL;
3500    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
3501       SRS_Resource__resourceMapping__nrofSymbols_n1;
3502    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
3503       SRS_Resource__resourceMapping__repetitionFactor_n1;
3504
3505    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
3506    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
3507    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
3508    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
3509    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
3510    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
3511       SRS_Resource__groupOrSequenceHopping_neither;
3512
3513    /* Setting resource type to aperiodic for intergration purposes */
3514    resourceList->list.array[rsrcIdx]->resourceType.present = \
3515            SRS_Resource__resourceType_PR_aperiodic;
3516    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
3517    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
3518       sizeof(struct SRS_Resource__resourceType__aperiodic));
3519    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
3520    {
3521       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3522       return RFAILED;
3523    }
3524    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
3525
3526    return ROK;
3527 }
3528
3529 /*******************************************************************
3530  *
3531  * @brief Build SRS resource set Add/mod list
3532  *
3533  * @details
3534  *
3535  *    Function : BuildSrsRsrcSetAddModList
3536  *
3537  *    Functionality: Build SRS resource set Add/mod list
3538  *
3539  * @params[in]
3540  * @return ROK     - success
3541  *         RFAILED - failure
3542  *
3543  * ****************************************************************/
3544 uint8_t BuildSrsRsrcSetAddModList
3545 (
3546 struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
3547 )
3548 {
3549    uint8_t  elementCnt;
3550    uint8_t  rSetIdx;
3551         uint8_t  rsrcIdx;
3552         struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
3553
3554    elementCnt = 1;
3555    rsrcSetList->list.count = elementCnt;
3556    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
3557    rsrcSetList->list.array = NULLP;
3558    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
3559    if(!rsrcSetList->list.array)
3560    {
3561       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3562       return RFAILED;
3563    }
3564
3565    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
3566    {
3567       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
3568       if(!rsrcSetList->list.array[rSetIdx])
3569       {
3570          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3571          return RFAILED;
3572       }
3573    }
3574
3575    rSetIdx = 0;
3576    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
3577
3578         /* Fill Resource Id list in resource set */
3579         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
3580         DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
3581            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
3582         if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
3583         {
3584            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3585                 return RFAILED;
3586         }
3587
3588         elementCnt = 1;
3589         rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
3590         rsrcIdList->list.count = elementCnt;
3591         rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
3592         rsrcIdList->list.array = NULLP;
3593         DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
3594         if(!rsrcIdList->list.array)
3595         {
3596            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3597                 return RFAILED;
3598         }
3599
3600         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
3601         {
3602            DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
3603                 if(!rsrcIdList->list.array[rsrcIdx])
3604                 {
3605                    DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3606                         return RFAILED;
3607                 }
3608         }
3609
3610         rsrcIdx = 0;
3611         *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
3612
3613         /* Fill resource type */
3614    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
3615       SRS_ResourceSet__resourceType_PR_aperiodic;
3616
3617    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
3618    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
3619       sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
3620    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
3621    {
3622            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3623                 return RFAILED;
3624         }
3625    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
3626            = APERIODIC_SRS_RESRC_TRIGGER;
3627
3628         /* TODO : Fill values for below IEs as expected by Viavi */
3629         rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
3630    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
3631
3632
3633    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
3634         rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
3635         rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
3636         rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
3637         rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
3638
3639    return ROK;
3640 }
3641
3642 /*******************************************************************
3643  *
3644  * @brief Builds BWP UL dedicated SRS Config
3645  *
3646  * @details
3647  *
3648  *    Function : BuildBWPUlDedSrsCfg
3649  *
3650  *    Functionality: Builds BWP UL dedicated SRS Config
3651  *
3652  * @params[in] SRS Config
3653  * @return ROK     - success
3654  *         RFAILED - failure
3655  *
3656  * ****************************************************************/
3657 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
3658 {
3659    srsCfg->srs_ResourceSetToReleaseList = NULLP;
3660    srsCfg->srs_ResourceSetToAddModList = NULLP;
3661    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
3662       sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
3663    if(!srsCfg->srs_ResourceSetToAddModList)
3664    {
3665       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3666       return RFAILED;
3667    }
3668    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
3669    {
3670       return RFAILED;
3671    }
3672
3673    srsCfg->srs_ResourceToReleaseList = NULLP;
3674
3675    /* Resource to Add/Modify list */
3676    srsCfg->srs_ResourceToAddModList = NULLP;
3677    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
3678       sizeof(struct SRS_Config__srs_ResourceToAddModList));
3679    if(!srsCfg->srs_ResourceToAddModList)
3680    {
3681       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3682       return RFAILED;
3683    }
3684
3685    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
3686    {
3687       return RFAILED;
3688    }
3689
3690    srsCfg->tpc_Accumulation = NULLP;
3691
3692    return ROK;
3693 }
3694
3695 /*******************************************************************
3696  *
3697  * @brief Builds inital UL BWP
3698  *
3699  * @details
3700  *
3701  *    Function : BuildInitialUlBWP
3702  *
3703  *    Functionality: Builds initial UL BWP
3704  *
3705  * @params[in] BWP_UplinkDedicated_t *ulBwp
3706  * @return ROK     - success
3707  *         RFAILED - failure
3708  *
3709  * ****************************************************************/
3710 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
3711 {
3712    ulBwp->pucch_Config = NULLP;
3713
3714    /* Fill BWP UL dedicated PUSCH config */
3715         ulBwp->pusch_Config = NULLP;
3716    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
3717    if(!ulBwp->pusch_Config)
3718    {
3719       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3720       return RFAILED;
3721    }
3722
3723    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
3724    ulBwp->pusch_Config->choice.setup = NULLP;
3725    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
3726    if(!ulBwp->pusch_Config->choice.setup)
3727    {
3728       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3729       return RFAILED;
3730    }
3731
3732    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
3733    {
3734       return RFAILED;
3735    }
3736
3737         ulBwp->configuredGrantConfig = NULLP;
3738
3739    /* Fill BPW UL dedicated SRS config */
3740         ulBwp->srs_Config = NULLP;
3741    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
3742    if(!ulBwp->srs_Config)
3743    {
3744       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3745       return RFAILED;
3746    }
3747
3748    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
3749    ulBwp->srs_Config->choice.setup = NULLP;
3750    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
3751    if(!ulBwp->srs_Config->choice.setup)
3752    {
3753       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3754       return RFAILED;
3755    }
3756
3757    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
3758    {
3759       return RFAILED;
3760    }
3761
3762         ulBwp->beamFailureRecoveryConfig = NULLP;
3763
3764    return ROK;
3765 }
3766
3767 /*******************************************************************
3768 *
3769 * @brief Builds Pusch Serving cell Config
3770 *
3771 * @details
3772 *
3773 *    Function : BuildPuschSrvCellCfg
3774 *
3775 *    Functionality: Builds Pusch Serving cell Config
3776 *
3777 * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
3778 *
3779 * @return ROK     - success
3780 *         RFAILED - failure
3781 *
3782 * ****************************************************************/
3783 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
3784 {
3785    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
3786    puschCfg->choice.setup = NULLP;
3787    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
3788    if(!puschCfg->choice.setup)
3789    {
3790       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3791       return RFAILED;
3792    }
3793
3794    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
3795         puschCfg->choice.setup->rateMatching = NULLP;
3796         puschCfg->choice.setup->xOverhead = NULLP;
3797    puschCfg->choice.setup->ext1 = NULLP;
3798    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
3799    if(!puschCfg->choice.setup->ext1)
3800    {
3801       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3802       return RFAILED;
3803    }
3804
3805    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
3806    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
3807    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
3808    {
3809       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3810       return RFAILED;
3811    }
3812    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
3813
3814    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
3815    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
3816    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
3817    {
3818       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3819       return RFAILED;
3820    }
3821    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
3822    return ROK;
3823 }
3824
3825 /*******************************************************************
3826  *
3827  * @brief Builds UL config
3828  * @details
3829  *
3830  *    Function : BuildUlCfg
3831  *
3832  *    Functionality: Builds UL config in spCellCfgDed
3833  *
3834  * @params[in] UplinkConfig_t *ulCfg
3835  *
3836  * @return ROK     - success
3837  *         RFAILED - failure
3838  *
3839  * ****************************************************************/
3840 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
3841 {
3842    ulCfg->initialUplinkBWP = NULLP;
3843    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
3844         if(!ulCfg->initialUplinkBWP)
3845         {
3846            DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
3847                 return RFAILED;
3848         }
3849
3850    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
3851         {
3852            return RFAILED;
3853         }
3854
3855    ulCfg->uplinkBWP_ToReleaseList = NULLP;
3856         ulCfg->uplinkBWP_ToAddModList = NULLP;
3857         ulCfg->firstActiveUplinkBWP_Id = NULLP;
3858    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
3859    if(!ulCfg->firstActiveUplinkBWP_Id)
3860    {
3861       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
3862       return RFAILED;
3863    }
3864    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
3865
3866    ulCfg->pusch_ServingCellConfig = NULLP;
3867    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
3868       sizeof(struct UplinkConfig__pusch_ServingCellConfig));
3869    if(!ulCfg->pusch_ServingCellConfig)
3870    {
3871       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
3872       return RFAILED;
3873    }
3874
3875    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
3876    {
3877       return RFAILED;
3878    }
3879
3880         ulCfg->carrierSwitching = NULLP;
3881         ulCfg->ext1 = NULLP;
3882         return ROK;
3883 }
3884
3885 /*******************************************************************
3886  *
3887  * @brief Builds PDSCH serving cell config
3888  * @details
3889  *
3890  *    Function : BuildPdschSrvCellCfg
3891  *
3892  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
3893  *
3894  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
3895  *
3896  * @return ROK     - success
3897  *         RFAILED - failure
3898  *
3899  * ****************************************************************/
3900 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
3901 {
3902    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
3903    pdschCfg->choice.setup = NULLP;
3904    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
3905    if(!pdschCfg->choice.setup)
3906    {
3907       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
3908       return RFAILED;
3909    }
3910
3911    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
3912         pdschCfg->choice.setup->xOverhead = NULLP;
3913    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
3914    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
3915    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
3916    {
3917       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
3918       return RFAILED;
3919    }
3920    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
3921         pdschCfg->choice.setup->pucch_Cell = NULLP;
3922         pdschCfg->choice.setup->ext1 = NULLP;
3923
3924    return ROK;
3925 }
3926
3927 /*******************************************************************
3928  *
3929  * @brief Builds CSI Meas config
3930  * @details
3931  *
3932  *    Function : BuildCsiMeasCfg
3933  *
3934  *    Functionality: Builds CSI Meas config in spCellCfgDed
3935  *
3936  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
3937  *
3938  * @return ROK     - success
3939  *         RFAILED - failure
3940  *
3941  * ****************************************************************/
3942 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
3943 {
3944
3945    return ROK;
3946 }
3947
3948 /*******************************************************************
3949  *
3950  * @brief Builds Spcell config dedicated
3951  * @details
3952  *
3953  *    Function : BuildSpCellCfgDed
3954  *
3955  *    Functionality: Builds sp cell config dedicated in spCellCfg
3956  *
3957  * @params[in] ServingCellConfig_t srvCellCfg
3958  *
3959  * @return ROK     - success
3960  *         RFAILED - failure
3961  *
3962  * ****************************************************************/
3963 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
3964 {
3965    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
3966
3967    srvCellCfg->initialDownlinkBWP = NULLP;
3968    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
3969         if(!srvCellCfg->initialDownlinkBWP)
3970         {
3971                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
3972                 return RFAILED;
3973         }
3974
3975    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
3976         {
3977                 DU_LOG("\nF1AP : BuildInitialDlBWP failed");
3978                 return RFAILED;
3979         }
3980    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
3981         srvCellCfg->downlinkBWP_ToAddModList = NULLP;
3982
3983    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
3984         DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
3985         if(!srvCellCfg->firstActiveDownlinkBWP_Id)
3986         {
3987                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
3988                 return RFAILED;
3989         }
3990         *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
3991
3992         srvCellCfg->bwp_InactivityTimer = NULLP;
3993
3994    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
3995         DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
3996         if(!srvCellCfg->defaultDownlinkBWP_Id)
3997         {
3998                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
3999                 return RFAILED;
4000         }
4001         *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4002
4003    srvCellCfg->uplinkConfig = NULLP;
4004    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4005         if(!srvCellCfg->uplinkConfig)
4006         {
4007                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4008                 return RFAILED;
4009         }
4010
4011    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4012         {
4013                 DU_LOG("\nF1AP : BuildUlCfg failed");
4014                 return RFAILED;
4015         }
4016         srvCellCfg->supplementaryUplink = NULLP;
4017         srvCellCfg->pdcch_ServingCellConfig = NULLP;
4018
4019    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4020         DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct     ServingCellConfig__pdsch_ServingCellConfig));
4021         if(!srvCellCfg->pdsch_ServingCellConfig)
4022         {
4023                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4024                 return RFAILED;
4025         }
4026
4027    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4028         {
4029                 DU_LOG("\nF1AP : BuildPdschSrvCellCfg failed");
4030                 return RFAILED;
4031         }
4032
4033    srvCellCfg->csi_MeasConfig = NULLP;
4034 #if 0
4035         DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct      ServingCellConfig__csi_MeasConfig))
4036         if(!srvCellCfg->csi_MeasConfig)
4037         {
4038                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4039                 return RFAILED;
4040         }
4041
4042    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4043         {
4044                 DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4045                 return RFAILED;
4046         }
4047 #endif
4048    srvCellCfg->sCellDeactivationTimer = NULLP;
4049         srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4050         srvCellCfg->tag_Id = TAG_ID;
4051    srvCellCfg->dummy = NULLP;
4052    srvCellCfg->pathlossReferenceLinking = NULLP;
4053    srvCellCfg->servingCellMO = NULLP;
4054    srvCellCfg->ext1 = NULLP;
4055
4056         return ROK;
4057 }
4058 /*******************************************************************
4059  *
4060  * @brief Builds Spcell config
4061  *
4062  * @details
4063  *
4064  *    Function : BuildSpCellCfg
4065  *
4066  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4067  *
4068  * @params[in] SpCellConfig_t spCellCfg
4069  *
4070  * @return ROK     - success
4071  *         RFAILED - failure
4072  *
4073  * ****************************************************************/
4074 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4075 {
4076
4077    spCellCfg->servCellIndex = NULLP;
4078         DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4079         if(!spCellCfg->servCellIndex)
4080         {
4081                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4082                 return RFAILED;
4083         }
4084    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4085
4086    spCellCfg->reconfigurationWithSync = NULLP;
4087         spCellCfg->rlf_TimersAndConstants = NULLP;
4088    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4089         DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4090         if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4091         {
4092                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4093                 return RFAILED;
4094         }
4095    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4096
4097    spCellCfg->spCellConfigDedicated = NULLP;
4098    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4099         if(!spCellCfg->spCellConfigDedicated)
4100         {
4101                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4102                 return RFAILED;
4103         }
4104    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4105         {
4106                 DU_LOG("\nF1AP : BuildSpCellCfgDed failed");
4107                 return RFAILED;
4108         }
4109         return ROK;
4110 }
4111 /*******************************************************************
4112 *
4113 * @brief Builds Phy cell group config
4114 *
4115 * @details
4116 *
4117 *    Function : BuildPhyCellGrpCfg
4118 *
4119 *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4120 *
4121 * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4122 *
4123 * @return ROK     - success
4124 *         RFAILED - failure
4125 *
4126 * ****************************************************************/
4127 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4128 {
4129    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4130         phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4131
4132    phyCellGrpCfg->p_NR_FR1 = NULLP;
4133         DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4134         if(!phyCellGrpCfg->p_NR_FR1)
4135         {
4136                 DU_LOG("\nF1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4137                 return RFAILED;
4138         }
4139    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4140         phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4141         phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4142         phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4143         phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4144         phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4145         phyCellGrpCfg->cs_RNTI = NULLP;
4146         phyCellGrpCfg->ext1 = NULLP;
4147         phyCellGrpCfg->ext2 = NULLP;
4148
4149         return ROK;
4150 }
4151 /*******************************************************************
4152 *
4153 * @brief Builds Mac cell group config
4154 *
4155 * @details
4156 *
4157 *    Function : BuildMacCellGrpCfg
4158 *
4159 *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4160 *
4161 * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4162 *
4163 * @return ROK     - success
4164 *         RFAILED - failure
4165 *
4166 * ****************************************************************/
4167 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4168 {
4169    macCellGrpCfg->drx_Config = NULLP;
4170    macCellGrpCfg->schedulingRequestConfig = NULLP;
4171         DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4172         if(!macCellGrpCfg->schedulingRequestConfig)
4173         {
4174                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4175                 return RFAILED;
4176         }
4177
4178         if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4179         {
4180            DU_LOG("\nF1AP : BuildSchedulingReqConfig failed");
4181                 return RFAILED;
4182         }
4183
4184    macCellGrpCfg->bsr_Config = NULLP;
4185    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4186         if(!macCellGrpCfg->bsr_Config)
4187         {
4188                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4189                 return RFAILED;
4190         }
4191
4192    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4193         {
4194       DU_LOG("\nF1AP : BuildBsrConfig failed");
4195            return RFAILED;
4196         }
4197
4198    macCellGrpCfg->tag_Config = NULLP;
4199    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4200         if(!macCellGrpCfg->tag_Config)
4201         {
4202                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4203                 return RFAILED;
4204         }
4205
4206    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4207         {
4208            DU_LOG("\nF1AP : BuildTagConfig failed");
4209            return RFAILED;
4210    }
4211
4212    macCellGrpCfg->phr_Config = NULLP;
4213    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4214         if(!macCellGrpCfg->phr_Config)
4215         {
4216                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4217                 return RFAILED;
4218         }
4219
4220    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4221         {
4222            DU_LOG("\nF1AP : BuildPhrConfig failed");
4223            return RFAILED;
4224    }
4225
4226    macCellGrpCfg->skipUplinkTxDynamic = false;
4227         macCellGrpCfg->ext1 = NULLP;
4228
4229         return ROK;
4230 }
4231  /*******************************************************************
4232  *
4233  * @brief Frees memeory allocated for SearchSpcToAddModList
4234  *
4235  * @details
4236  *
4237  *    Function : FreeSearchSpcToAddModList
4238  *
4239  *    Functionality: Deallocating memory of SearchSpcToAddModList
4240  *
4241  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4242  *
4243  * @return void
4244  *
4245  4221 * ****************************************************************/
4246 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4247 {
4248     uint8_t idx1=0;
4249     uint8_t idx2=0;
4250     struct  SearchSpace *searchSpc=NULLP;
4251
4252     if(searchSpcList->list.array)
4253          {
4254             if(searchSpcList->list.array[idx2])
4255             {
4256           searchSpc = searchSpcList->list.array[idx2];
4257                if(searchSpc->controlResourceSetId)
4258                {
4259                   if(searchSpc->monitoringSlotPeriodicityAndOffset)
4260                   {
4261                      if(searchSpc->monitoringSymbolsWithinSlot)
4262                      {
4263                         if(searchSpc->monitoringSymbolsWithinSlot->buf)
4264                         {
4265                            if(searchSpc->nrofCandidates)
4266                            {
4267                               if(searchSpc->searchSpaceType)
4268                               {
4269                                  DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4270                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4271                                  DU_FREE(searchSpc->searchSpaceType, sizeof(struct
4272                                                                          SearchSpace__searchSpaceType));
4273                               }
4274                               DU_FREE(searchSpc->nrofCandidates,
4275                               sizeof(struct SearchSpace__nrofCandidates));
4276                            }
4277                            DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4278                            searchSpc->monitoringSymbolsWithinSlot->size);
4279                         }
4280                         DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4281                         sizeof(BIT_STRING_t));
4282                      }
4283                      DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4284                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4285                   }
4286                   DU_FREE(searchSpc->controlResourceSetId,
4287                   sizeof(ControlResourceSetId_t));
4288                      }
4289                   }
4290                   for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4291              {
4292                  DU_FREE(searchSpcList->list.array[idx1],
4293                                 sizeof(struct SearchSpace));
4294                   }
4295                   DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4296          }
4297 }
4298  /*******************************************************************
4299  *
4300  * @brief Frees memory allocated for PdschTimeDomAllocList
4301  *
4302  * @details
4303  *
4304  *    Function : FreePdschTimeDomAllocList
4305  *
4306  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4307  *
4308  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4309  *
4310  * @return void
4311  *
4312  4221 * ****************************************************************/
4313 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4314 {
4315    uint8_t idx1=0;
4316
4317         if(timeDomAllocList->choice.setup)
4318    {
4319       if(timeDomAllocList->choice.setup->list.array)
4320       {
4321           for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4322           {
4323              DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4324              sizeof(struct PDSCH_TimeDomainResourceAllocation));
4325           }
4326           DU_FREE(timeDomAllocList->choice.setup->list.array, \
4327           timeDomAllocList->choice.setup->list.size);
4328       }
4329       DU_FREE(timeDomAllocList->choice.setup,\
4330       sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4331    }
4332 }
4333  /*******************************************************************
4334  *
4335  * @brief Frees memory allocated for PuschTimeDomAllocList
4336  *
4337  *@details
4338  *
4339  *    Function : FreePuschTimeDomAllocList
4340  *
4341  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4342  *
4343  * @params[in] PUSCH_Config_t *puschCfg
4344  *
4345  * @return void
4346  *
4347  4221 * ****************************************************************/
4348 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4349 {
4350     uint8_t idx1=0;
4351          uint8_t idx2=0;
4352     struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4353
4354     if(puschCfg->pusch_TimeDomainAllocationList)
4355     {
4356        timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4357        if(timeDomAllocList_t->choice.setup)
4358        {
4359           if(timeDomAllocList_t->choice.setup->list.array)
4360           {
4361              DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4362              for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4363              {
4364                 DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4365                                     sizeof(PUSCH_TimeDomainResourceAllocation_t));
4366                                  }
4367                                  DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4368              timeDomAllocList_t->choice.setup->list.size);
4369           }
4370           DU_FREE(timeDomAllocList_t->choice.setup, \
4371                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4372        }
4373                  DU_FREE(puschCfg->transformPrecoder, sizeof(long));
4374        DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4375                  sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4376     }
4377
4378 }
4379  /*******************************************************************
4380  *
4381  * @brief Frees memory allocated for InitialUlBWP
4382  *
4383  * @details
4384  *
4385  *    Function : FreeInitialUlBWP
4386  *
4387  *    Functionality: Deallocating memory of InitialUlBWP
4388  *
4389  * @params[in] BWP_UplinkDedicated_t *ulBwp
4390  *
4391  * @return void
4392  *
4393  * ****************************************************************/
4394 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4395 {
4396     uint8_t  rSetIdx, rsrcIdx;
4397     SRS_Config_t   *srsCfg = NULLP;
4398     PUSCH_Config_t *puschCfg = NULLP;
4399     struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
4400          struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
4401          struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
4402          struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
4403
4404          if(ulBwp->pusch_Config)
4405     {
4406        if(ulBwp->pusch_Config->choice.setup)
4407        {
4408           puschCfg=ulBwp->pusch_Config->choice.setup;
4409           if(puschCfg->dataScramblingIdentityPUSCH)
4410           {
4411              if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4412              {
4413                 FreePuschTimeDomAllocList(puschCfg);
4414                 dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
4415                                          if(dmrsUlCfg->choice.setup)
4416                 {
4417                    if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4418                    {
4419                       if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4420                       {
4421                          DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4422                                                                  sizeof(long));
4423                                                                  DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
4424                          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4425                                                          }
4426                                                          DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
4427                                                          sizeof(long));
4428                                                  }
4429                                                  DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
4430                 }
4431                                          DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4432                                          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4433                                  }
4434              DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4435           }
4436           DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4437             }
4438                  DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4439
4440                  /* Free SRS-Config */
4441                  if(ulBwp->srs_Config)
4442                  {
4443                     if(ulBwp->srs_Config->choice.setup)
4444                          {
4445                             srsCfg = ulBwp->srs_Config->choice.setup;
4446
4447                                  /* Free Resource Set to add/mod list */
4448                             if(srsCfg->srs_ResourceSetToAddModList)
4449                                  {
4450                                     rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
4451                                          if(rsrcSetList->list.array)
4452                                          {
4453                                             rSetIdx = 0;
4454
4455                                                  /* Free SRS resource Id list in this SRS resource set */
4456                                                  if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4457                                                  {
4458                                                     rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4459
4460                                                     if(rsrcIdList->list.array)
4461                                                          {
4462                                                             for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4463                                                                  {
4464                                                                     DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4465                                                             }
4466                                                             DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
4467                                                          }
4468                                                     DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4469                                                             sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4470                                                  }
4471
4472                                                  /* Free resource type info for this SRS resource set */
4473                                                  DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4474                                                     sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4475
4476                                                  /* Free memory for each resource set */
4477                                             for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4478                                                  {
4479                                                     DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4480                                                  }
4481                                             DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
4482                                          }
4483                                     DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
4484                                             sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4485                                  }
4486
4487                                  /* Free resource to add/modd list */
4488                                  if(srsCfg->srs_ResourceToAddModList)
4489                                  {
4490                                     resourceList = srsCfg->srs_ResourceToAddModList;
4491                                          if(resourceList->list.array)
4492                                          {
4493                                             rsrcIdx = 0;
4494                                                  DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
4495                                                     sizeof(struct SRS_Resource__transmissionComb__n2));
4496                                             DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
4497                                                     sizeof(struct SRS_Resource__resourceType__aperiodic));
4498
4499                                             for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4500                                                  {
4501                                                     DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4502                    }
4503                                             DU_FREE(resourceList->list.array, resourceList->list.size);
4504                                          }
4505                                     DU_FREE(srsCfg->srs_ResourceToAddModList, \
4506                                             sizeof(struct SRS_Config__srs_ResourceToAddModList));
4507                                  }
4508
4509                             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4510                          }
4511                     DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4512        }
4513          }
4514 }
4515  /*******************************************************************
4516  *
4517  * @brief Frees memory allocated for initialUplinkBWP
4518  *
4519  * @details
4520  *
4521  *    Function : FreeinitialUplinkBWP
4522  *
4523  *    Functionality: Deallocating memory of initialUplinkBWP
4524  *
4525  * @params[in] UplinkConfig_t *ulCfg
4526  *
4527  * @return void
4528  *
4529  *
4530  * ****************************************************************/
4531 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
4532 {
4533    BWP_UplinkDedicated_t *ulBwp=NULLP;
4534    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
4535
4536         if(ulCfg->initialUplinkBWP)
4537         {
4538            ulBwp=ulCfg->initialUplinkBWP;
4539            if(ulCfg->firstActiveUplinkBWP_Id)
4540            {
4541               if(ulCfg->pusch_ServingCellConfig)
4542               {
4543                  puschCfg=ulCfg->pusch_ServingCellConfig;
4544                  if(puschCfg->choice.setup)
4545                  {
4546                     if(puschCfg->choice.setup->ext1)
4547                     {
4548                         DU_FREE(puschCfg->choice.setup->ext1->\
4549                                                  processingType2Enabled,sizeof(BOOLEAN_t));
4550                         DU_FREE(puschCfg->choice.setup->ext1->\
4551                                                  maxMIMO_Layers,sizeof(long));
4552                                                  DU_FREE(puschCfg->choice.setup->ext1, \
4553                                                  sizeof(struct PUSCH_ServingCellConfig__ext1));
4554                                         }
4555                     DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4556                  }
4557                  DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4558               }
4559               DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4560            }
4561            FreeInitialUlBWP(ulBwp);
4562            DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4563         }
4564 }
4565  /*******************************************************************
4566  *
4567  * @brief Frees emmory allocated for BWPDlDedPdschCfg
4568  *
4569  * @details
4570  *
4571  *    Function : FreeBWPDlDedPdschCfg
4572  *
4573  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
4574  *
4575  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4576  *
4577  * @return void
4578  *
4579  *
4580  * ****************************************************************/
4581 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
4582 {
4583    struct PDSCH_Config *pdschCfg=NULLP;
4584         struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
4585    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
4586    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
4587
4588         if(dlBwp->pdsch_Config->choice.setup)
4589    {
4590       pdschCfg=dlBwp->pdsch_Config->choice.setup;
4591       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4592       {
4593           if(pdschCfg->pdsch_TimeDomainAllocationList)
4594           {
4595              timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
4596              if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
4597              {
4598                 prbBndlType=&pdschCfg->prb_BundlingType;
4599                 DU_FREE(prbBndlType->choice.staticBundling,\
4600                 sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4601                 DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4602              }
4603              FreePdschTimeDomAllocList(timeDomAllocList);
4604              DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
4605              sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4606           }
4607           dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
4608           if(dmrsDlCfg->choice.setup)
4609           {
4610              DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
4611              sizeof(long));
4612              DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
4613           }
4614           DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4615           sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4616        }
4617        DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4618     }
4619 }
4620  /*******************************************************************
4621  *
4622  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
4623  *
4624  * @details
4625  *
4626  *    Function : FreeBWPDlDedPdcchCfg
4627  *
4628  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
4629  *
4630  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4631  *
4632  * @return void
4633  *
4634  *
4635  * ****************************************************************/
4636 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
4637 {
4638    uint8_t idx1=0;
4639         uint8_t idx2=0;
4640         struct PDCCH_Config *pdcchCfg=NULLP;
4641    struct ControlResourceSet *controlRSet=NULLP;
4642         struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
4643
4644         if(dlBwp->pdcch_Config->choice.setup)
4645    {
4646       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
4647       if(pdcchCfg->controlResourceSetToAddModList)
4648       {
4649          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
4650          if(controlRSetList->list.array)
4651          {
4652             controlRSet = controlRSetList->list.array[idx2];
4653             if(controlRSet)
4654             {
4655                if(controlRSet->frequencyDomainResources.buf)
4656                {
4657                   if(controlRSet->pdcch_DMRS_ScramblingID)
4658                   {
4659                      if(pdcchCfg->searchSpacesToAddModList)
4660                      {
4661                          FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
4662                          DU_FREE(pdcchCfg->searchSpacesToAddModList, \
4663                          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
4664                      }
4665                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
4666                   }
4667                                                 DU_FREE(controlRSet->frequencyDomainResources.buf, \
4668                                                 controlRSet->frequencyDomainResources.size);
4669                                         }
4670                                 }
4671             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
4672             {
4673                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
4674             }
4675                                 DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
4676                         }
4677                         DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
4678                         sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
4679                 }
4680                 DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4681         }
4682 }
4683
4684 /*******************************************************************
4685  *
4686  * @brief Frees emmory allocated for DUToCURRCContainer
4687  *
4688  * @details
4689  *
4690  *    Function : FreeMemDuToCuRrcCont
4691  *
4692  *    Functionality: Deallocating memory of DuToCuRrcContainer
4693  *
4694  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
4695  *
4696  * @return ROK     - success
4697  *         RFAILED - failure
4698  *
4699 * ****************************************************************/
4700 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
4701 {
4702    uint8_t idx=0;
4703         SpCellConfig_t *spCellCfg=NULLP;
4704         ServingCellConfig_t *srvCellCfg=NULLP;
4705         BWP_DownlinkDedicated_t *dlBwp=NULLP;
4706         MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
4707         PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
4708         struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
4709         struct RLC_Config *rlcConfig=NULLP;
4710         struct LogicalChannelConfig *macLcConfig=NULLP;
4711         struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
4712         struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
4713         struct TAG_Config *tagConfig=NULLP;
4714         struct TAG_Config__tag_ToAddModList *tagList=NULLP;
4715         struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
4716         struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
4717
4718         rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
4719         if(rlcBearerList)
4720         {
4721                 if(rlcBearerList->list.array)
4722                 {
4723                         for(idx=0; idx<rlcBearerList->list.count; idx++)
4724                         {
4725                                 if(rlcBearerList->list.array[idx])
4726                                 {
4727                                    rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
4728                                    macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
4729                                    if(rlcConfig)
4730                                    {
4731                                       if(rlcConfig->choice.am)
4732                                            {
4733                                          DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
4734                                          DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
4735                                          DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
4736                                                 }
4737                                       DU_FREE(rlcConfig, sizeof(struct RLC_Config));
4738                }
4739                                    DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
4740                                 if(macLcConfig)
4741                                    {
4742                                       if(macLcConfig->ul_SpecificParameters)
4743                                            {
4744                                          DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,       sizeof(SchedulingRequestId_t));
4745                                          DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,       sizeof(long));
4746                                          DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
4747                                       }
4748                                       DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
4749                                    }
4750                                    DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
4751                                 }
4752                         }
4753                         DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
4754                 }
4755                 DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
4756         }
4757
4758         macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
4759         if(macCellGrpCfg)
4760         {
4761                 schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
4762       if(schedulingRequestConfig)
4763                 {
4764                    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
4765                         if(schReqList)
4766                         {
4767                            if(schReqList->list.array)
4768                                 {
4769                          for(idx=0;idx<schReqList->list.count; idx++)
4770                          {
4771                                            if(schReqList->list.array[idx])
4772                                                 {
4773                                     DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
4774                                     DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
4775                             }
4776                                         }
4777                          DU_FREE(schReqList->list.array, schReqList->list.size);
4778                                 }
4779                       DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
4780                                 sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
4781                    DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4782       }
4783                 if(macCellGrpCfg->bsr_Config)
4784                 {
4785                    DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4786                 }
4787                 tagConfig = macCellGrpCfg->tag_Config;
4788                 if(tagConfig)
4789                 {
4790                    tagList = tagConfig->tag_ToAddModList;
4791                         if(tagList)
4792                         {
4793                            if(tagList->list.array)
4794                                 {
4795                          for(idx=0; idx<tagList->list.count; idx++)
4796                          {
4797                    DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
4798                                         }
4799                          DU_FREE(tagList->list.array, tagList->list.size);
4800             }
4801                       DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
4802                         }
4803                    DU_FREE(tagConfig, sizeof(struct TAG_Config));
4804                 }
4805
4806                 phrConfig = macCellGrpCfg->phr_Config;
4807                 if(phrConfig)
4808                 {
4809                    DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
4810                    DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
4811       }
4812
4813                 DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
4814         }
4815
4816         phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
4817         if(phyCellGrpCfg)
4818         {
4819                 DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4820                 DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
4821         }
4822
4823         spCellCfg = cellGrpCfg->spCellConfig;
4824         if(spCellCfg)
4825         {
4826            if(spCellCfg->servCellIndex)
4827                 {
4828                    if(spCellCfg->rlmInSyncOutOfSyncThreshold)
4829                         {
4830                            if(spCellCfg->spCellConfigDedicated)
4831                                 {
4832                                    srvCellCfg = spCellCfg->spCellConfigDedicated;
4833                if(srvCellCfg->initialDownlinkBWP)
4834                                         {
4835                                            dlBwp = srvCellCfg->initialDownlinkBWP;
4836                                            if(srvCellCfg->firstActiveDownlinkBWP_Id)
4837                                                 {
4838                                                    if(srvCellCfg->defaultDownlinkBWP_Id)
4839                                                    {
4840                                                            if(srvCellCfg->uplinkConfig)
4841                                                                 {
4842                                                               if(srvCellCfg->pdsch_ServingCellConfig)
4843                                                                    {
4844                                                                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
4845                                                                             if(pdschCfg->choice.setup)
4846                                                                             {
4847                                                                                  DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
4848                                                                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4849                                                                                  }
4850                                                                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
4851                                                                                  ServingCellConfig__pdsch_ServingCellConfig));
4852                                                                          }
4853                                                                     FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
4854                                                                          DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4855                                                                 }
4856                                                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4857                                                         }
4858                                                    DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4859                                                 }
4860                   if(dlBwp->pdcch_Config)
4861                                            {
4862                                                     if(dlBwp->pdsch_Config)
4863                                                     {
4864                                                        FreeBWPDlDedPdschCfg(dlBwp);
4865                                                             DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4866                                                }
4867                                                     FreeBWPDlDedPdcchCfg(dlBwp);
4868                                                     DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4869                                            }
4870                                                 DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4871                                         }
4872                                         DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4873                                 }
4874                            DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4875                         }
4876                    DU_FREE(spCellCfg->servCellIndex, sizeof(long));
4877       }
4878                 DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
4879         }
4880         return ROK;
4881 }
4882 /*******************************************************************
4883  *
4884  * @brief Builds DU To CU RRC Container
4885  *
4886  * @details
4887  *
4888  *    Function : BuildDuToCuRrcContainer
4889  *
4890  *    Functionality: Builds DuToCuRrcContainer
4891  *
4892  * @params[in] idx, index in F1AP msg
4893  *             DuToCuRRCContainer, DuToCuRRCContainer
4894  *
4895  * @return ROK     - success
4896  *         RFAILED - failure
4897  *
4898  * ****************************************************************/
4899 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
4900 {
4901         CellGroupConfigRrc_t  cellGrpCfg;
4902         asn_enc_rval_t        encRetVal;
4903         uint8_t               ret = RFAILED;
4904
4905         while(true)
4906         {
4907                 cellGrpCfg.cellGroupId = CELL_GRP_ID;
4908
4909                 cellGrpCfg.rlc_BearerToAddModList = NULLP;
4910                 DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
4911                 if(!cellGrpCfg.rlc_BearerToAddModList)
4912                 {
4913                         DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
4914                         break;
4915                 }
4916                 if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
4917                 {
4918                         DU_LOG("\nF1AP : BuildRlcBearerToAddModList failed");
4919                         break;
4920                 }
4921
4922       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
4923                 cellGrpCfg.mac_CellGroupConfig = NULLP;
4924                 DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
4925                 if(!cellGrpCfg.mac_CellGroupConfig)
4926                 {
4927                         DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
4928                         break;
4929                 }
4930                 if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
4931                 {
4932                         DU_LOG("\nF1AP : BuildMacCellGrpCfg failed");
4933                         break;
4934                 }
4935
4936
4937                 cellGrpCfg.physicalCellGroupConfig = NULLP;
4938                 DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
4939                 if(!cellGrpCfg.physicalCellGroupConfig)
4940                 {
4941                         DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
4942                         break;
4943                 }
4944                 if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
4945                 {
4946                         DU_LOG("\nF1AP : BuildPhyCellGrpCfg failed");
4947                         break;
4948                 }
4949
4950                 cellGrpCfg.spCellConfig = NULLP;
4951                 DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
4952                 if(!cellGrpCfg.spCellConfig)
4953                 {
4954                         DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
4955                         break;
4956                 }
4957                 if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
4958                 {
4959                         DU_LOG("\nF1AP : BuildSpCellCfg failed");
4960                         break;
4961                 }
4962
4963       cellGrpCfg.sCellToAddModList = NULLP;
4964                 cellGrpCfg.sCellToReleaseList = NULLP;
4965                 cellGrpCfg.ext1 = NULLP;
4966
4967                 /* encode cellGrpCfg into duToCuRrcContainer */
4968                 xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
4969                 memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
4970                 encBufSize = 0;
4971                 encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
4972                 /* Encode results */
4973                 if(encRetVal.encoded == ENCODE_FAIL)
4974                 {
4975                         DU_LOG( "\n F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
4976                                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4977                         break;
4978                 }
4979                 else
4980                 {
4981                         DU_LOG("\n F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
4982                         for(int i=0; i< encBufSize; i++)
4983                         {
4984                                 printf("%x",encBuf[i]);
4985                         }
4986                 }
4987
4988            duToCuRrcContainer->size = encBufSize;
4989                 DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
4990                 if(!duToCuRrcContainer->buf)
4991                 {
4992          DU_LOG("\nF1AP : Memory allocation failed in BuildDuToCuRrcContainer");
4993                         break;
4994                 }
4995                 memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
4996                 ret = ROK;
4997                 break;
4998         }
4999    FreeMemDuToCuRrcCont(&cellGrpCfg);
5000         return ret;
5001 }
5002
5003 /*******************************************************************
5004  *
5005  * @brief Builds and sends the InitialULRRCMessage
5006  *
5007  * @details
5008  *
5009  *    Function : BuildAndSendInitialRrcMsgTransfer
5010  *
5011  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
5012  *                   it to the CU through SCTP.
5013  *
5014  * @params[in]
5015  *
5016  * @return ROK     - success
5017  *         RFAILED - failure
5018  *
5019  * ****************************************************************/
5020 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
5021         uint16_t rrcContSize, uint8_t *rrcContainer)
5022 {
5023    uint8_t   ret;
5024         uint8_t   elementCnt;
5025    uint8_t   ieId;
5026         uint8_t   idx;
5027         uint8_t   idx1;
5028         F1AP_PDU_t  *f1apMsg = NULLP;
5029         InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5030    asn_enc_rval_t                encRetVal;
5031         bool  checkvar=false;
5032         while(true)
5033         {
5034              DU_LOG("\n F1AP : Building RRC Setup Request\n");
5035                   DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5036                   if(f1apMsg == NULLP)
5037                   {
5038                       DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
5039                            break;
5040                   }
5041                   f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5042                   DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5043                   if(f1apMsg->choice.initiatingMessage == NULLP)
5044                   {
5045                      DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
5046                           break;
5047                   }
5048                   f1apMsg->choice.initiatingMessage->procedureCode =\
5049                          ProcedureCode_id_InitialULRRCMessageTransfer;
5050                   f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5051                   f1apMsg->choice.initiatingMessage->value.present = \
5052                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5053                   initULRRCMsg =\
5054                          &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5055         elementCnt = 5;
5056                   initULRRCMsg->protocolIEs.list.count = elementCnt;
5057                   initULRRCMsg->protocolIEs.list.size = \
5058                          elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5059                   /* Initialize the F1Setup members */
5060                    DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5061                    if(initULRRCMsg->protocolIEs.list.array == NULLP)
5062                    {
5063                       DU_LOG(" F1AP : Memory allocation for\
5064                                 RRCSetupRequestMessageTransferIEs failed");
5065                                 break;
5066                    }
5067                    for(idx=0; idx<elementCnt; idx++)
5068               {
5069                            DU_ALLOC(initULRRCMsg->protocolIEs.list.array[idx],\
5070                                  sizeof(InitialULRRCMessageTransferIEs_t));
5071                                  if(initULRRCMsg->protocolIEs.list.array[idx] == NULLP)
5072                                  {
5073                                      break;
5074                                  }
5075                    }
5076                    idx1 = 0;
5077                    /*GNB DU UE F1AP ID*/
5078                    initULRRCMsg->protocolIEs.list.array[idx1]->id  = \
5079                                       ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5080                         initULRRCMsg->protocolIEs.list.array[idx1]->criticality  = Criticality_reject;
5081                    initULRRCMsg->protocolIEs.list.array[idx1]->value.present = \
5082                                       InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5083                    initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5084
5085
5086                         /*NRCGI*/
5087                         idx1++;
5088                         initULRRCMsg->protocolIEs.list.array[idx1]->id  = \
5089                                  ProtocolIE_ID_id_NRCGI;
5090                         initULRRCMsg->protocolIEs.list.array[idx1]->criticality  =Criticality_reject;
5091                         initULRRCMsg->protocolIEs.list.array[idx1]->value.present = \
5092                        InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5093
5094                         ret =\
5095                         BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI);
5096               if(ret!=ROK)
5097                         {
5098                             break;
5099                         }
5100
5101                         /*CRNTI*/
5102                         idx1++;
5103                         initULRRCMsg->protocolIEs.list.array[idx1]->id  = \
5104                                        ProtocolIE_ID_id_C_RNTI;
5105                         initULRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
5106                         initULRRCMsg->protocolIEs.list.array[idx1]->value.present =\
5107                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
5108                         initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.C_RNTI = crnti;
5109
5110          /*RRCContainer*/
5111                         idx1++;
5112                         initULRRCMsg->protocolIEs.list.array[idx1]->id  = \
5113                                        ProtocolIE_ID_id_RRCContainer;
5114                         initULRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
5115                         initULRRCMsg->protocolIEs.list.array[idx1]->value.present =\
5116                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
5117
5118                         initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = rrcContSize;
5119                         DU_ALLOC(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
5120                               initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
5121                         if(!initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
5122                         {
5123                            DU_LOG(" F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
5124                                 break;
5125
5126                         }
5127                         memcpy(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, rrcContainer,
5128                               initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
5129
5130
5131                         /*DUtoCURRCContainer*/
5132                         idx1++;
5133                         initULRRCMsg->protocolIEs.list.array[idx1]->id  = \
5134                                        ProtocolIE_ID_id_DUtoCURRCContainer;
5135                         initULRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
5136                         initULRRCMsg->protocolIEs.list.array[idx1]->value.present =\
5137                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
5138
5139                         ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer);
5140          if(ret != ROK)
5141                         {
5142                            break;
5143                         }
5144
5145                         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5146
5147                         /* Encode the F1SetupRequest type as APER */
5148                         memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
5149                         encBufSize = 0;
5150                         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
5151                         /* Encode results */
5152                         if(encRetVal.encoded == ENCODE_FAIL)
5153                         {
5154                             DU_LOG( "\n F1AP : Could not encode Initial UL RRC Message Transfer\
5155                                     structure (at %s)\n",encRetVal.failed_type ? \
5156                                          encRetVal.failed_type->name : "unknown");
5157                                  break;
5158                         }
5159                         else
5160                         {
5161
5162                                   DU_LOG("\n F1AP : Created APER encoded buffer for Initial UL RRC\
5163                                   Message transfer\n");
5164                                    for(int i=0; i< encBufSize; i++)
5165                                         {
5166                                             printf("%x",encBuf[i]);
5167                                         }
5168                         }
5169                         /* Sending  msg  */
5170                         if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
5171                         {
5172                             DU_LOG("\n F1AP : Sending Initial UL RRC Message Transfer Failed");
5173                                  break;
5174                         }
5175                         checkvar=true;
5176                         break;
5177         }
5178
5179         if(f1apMsg != NULLP)
5180    {
5181             if(f1apMsg->choice.initiatingMessage != NULLP)
5182                  {
5183                      if(initULRRCMsg->protocolIEs.list.array != NULLP)
5184                           {
5185                          if(idx == elementCnt)
5186                               {
5187                                        idx1=1;
5188                                   if(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.pLMN_Identity.buf!=NULLP)
5189                                        {
5190                                            if(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.nRCellIdentity.buf!=NULLP)
5191                                                 {
5192                                                     DU_FREE(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.nRCellIdentity.buf,
5193                                                          initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.nRCellIdentity.size);
5194                                                 }
5195                                                 DU_FREE(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.pLMN_Identity.buf,\
5196                                                  initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.NRCGI.pLMN_Identity.size);
5197                                         }
5198
5199                                                   idx1=3;
5200                                                   if(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
5201                                                   {
5202                                                           DU_FREE(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
5203                                                                           initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
5204                                                   }
5205
5206                                                   idx1 = 4;
5207                                                   if(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer.buf)
5208                                                   {
5209                                                      DU_FREE(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer.buf,
5210                                                           initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer.size);
5211                                                   }
5212                                         for(ieId=0; ieId<elementCnt; ieId++)
5213                                         {
5214                                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieId],sizeof(InitialULRRCMessageTransferIEs_t));
5215                                         }
5216                                }
5217                                else
5218                                {
5219                                     for(ieId=0; ieId<idx; ieId++)
5220                                               {
5221                                                   DU_FREE(initULRRCMsg->protocolIEs.list.array[ieId],sizeof(InitialULRRCMessageTransferIEs_t));
5222                                               }
5223                                }
5224                                          DU_FREE(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5225                          }
5226                          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5227                  }
5228                  DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5229         }
5230         if(checkvar==true)
5231            return ROK;
5232         else
5233            return RFAILED;
5234 }/* End of BuildAndSendInitialRrcMsgTransfer*/
5235
5236 /*******************************************************************
5237  *
5238  * @brief Builds Special cell list for UE Setup Request
5239  *
5240  * @details
5241  *
5242  *    Function : BuildSplCellList
5243  *
5244  *    Functionality: Constructs the Special Cell list for UESetReq
5245  *
5246  * @params[in] SCell_ToBeSetup_List_t *spCellLst
5247  *
5248  * @return ROK     - success
5249  *         RFAILED - failure
5250  *
5251  * ****************************************************************/
5252 uint8_t BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
5253 {
5254         uint8_t  cellCnt;
5255         uint8_t  idx;
5256         uint8_t  ret;
5257         cellCnt = 1;
5258         spCellLst->list.count = cellCnt;
5259         spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
5260         DU_ALLOC(spCellLst->list.array,spCellLst->list.size);
5261         if(spCellLst->list.array == NULLP)
5262         {
5263                 return RFAILED;
5264         }
5265         for(idx=0; idx<cellCnt; idx++)
5266         {
5267                 DU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
5268                 if(spCellLst->list.array[idx] == NULLP)
5269                 {
5270                         return RFAILED;
5271                 }
5272         }
5273         idx = 0;
5274         spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
5275         spCellLst->list.array[idx]->criticality = Criticality_ignore;
5276         spCellLst->list.array[idx]->value.present =\
5277                 SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
5278         /* Special Cell ID -NRCGI */
5279         ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
5280         if(ret != ROK)
5281         {
5282                 return RFAILED;
5283         }
5284         /*Special Cell Index*/
5285         spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
5286   return ROK;
5287 }/* End of BuildSplCellList*/
5288
5289 /*******************************************************************
5290  *
5291  * @brief Builds SRBS to be setup
5292  *
5293  * @details
5294  *
5295  *    Function : BuildSRBSetup
5296  *
5297  *    Functionality: Constructs the SRB's for UESetReq
5298  *
5299  * @params[in] SRBs_ToBeSetup_List_t *srbSet
5300  *
5301  * @return ROK     - success
5302  *         RFAILED - failure
5303  *
5304  * ****************************************************************/
5305 uint8_t BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
5306 {
5307         uint8_t idx;
5308         uint8_t srbCnt;
5309         srbCnt = 1;
5310         srbSet->list.count = srbCnt;
5311         srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
5312         DU_ALLOC(srbSet->list.array,srbSet->list.size);
5313         if(srbSet->list.array == NULLP)
5314         {
5315                 return RFAILED;
5316         }
5317         for(idx=0; idx<srbCnt; idx++)
5318         {
5319                 DU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
5320                 if(srbSet->list.array[idx] == NULLP)
5321            {
5322                    return RFAILED;
5323                 }
5324         }
5325         idx = 0;
5326         srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
5327         srbSet->list.array[idx]->criticality = Criticality_ignore;
5328         srbSet->list.array[idx]->value.present = \
5329                         SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
5330    srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
5331    return ROK;
5332 }/* End of BuildSRBSetup*/
5333
5334 /*******************************************************************
5335  *
5336  * @brief Builds QOS Info for DRB Setum Item
5337  *
5338  * @details
5339  *
5340  *    Function : BuildQOSInfo
5341  *
5342  *    Functionality: Constructs the QOS Info for DRB Setup Item
5343  *
5344  * @params[in] QoSInformation_t *qosinfo
5345  *
5346  * @return ROK     - success
5347  *         RFAILED - failure
5348  *
5349  * ****************************************************************/
5350 uint8_t BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
5351 {
5352         /* NonDynamic5QIDescriptor */
5353         drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
5354         DU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
5355         if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
5356         {
5357                 return RFAILED;
5358         }
5359         /*FiveQI*/
5360         drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = 0;
5361         /*AveragingWindow*/
5362         DU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
5363                                                                                                 sizeof(AveragingWindow_t));
5364         if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
5365                                                                                                                                                                                                         NULLP)
5366         {
5367                 return RFAILED;
5368         }
5369         *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
5370         /*MaxDataBurstVolume*/
5371         DU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
5372                                                                                                 sizeof(MaxDataBurstVolume_t));
5373         if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
5374                                                                                                                                                                                                         NULLP)
5375         {
5376                 return RFAILED;
5377         }
5378         *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
5379
5380         /*nRGRAN Allocation Retention Priority*/
5381         drbQos->nGRANallocationRetentionPriority.priorityLevel =        \
5382                                                                                                 PriorityLevel_highest;
5383         drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = \
5384                                                         Pre_emptionCapability_may_trigger_pre_emption;
5385         drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = \
5386                                                                 Pre_emptionVulnerability_not_pre_emptable;
5387
5388         /* TO DO: GBR_QoSFlowInformation */
5389         return ROK;
5390 }/*End of BuildQOSInfo*/
5391
5392 /*******************************************************************
5393  *
5394  * @brief Builds SNSSAI
5395  *
5396  * @details
5397  *
5398  *    Function : BuildSNSSAI
5399  *
5400  *    Functionality: Constructs the SNSSAI For DRB list
5401  *
5402  * @params[in] SNSSAI_t *snssai
5403  *
5404  * @return ROK     - success
5405  *         RFAILED - failure
5406  *
5407  * ****************************************************************/
5408 uint8_t BuildSNSSAI(SNSSAI_t *snssai)
5409 {
5410         /*SNSSAI*/
5411           /*ssT*/
5412         snssai->sST.size = sizeof(uint8_t);
5413         DU_ALLOC(snssai->sST.buf,snssai->sST.size);
5414         if(snssai->sST.buf == NULLP)
5415         {
5416                 return RFAILED;
5417         }
5418         snssai->sST.buf[0] = 3;
5419           /*sD*/
5420         DU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
5421         if(snssai->sD == NULLP)
5422         {
5423                 return RFAILED;
5424         }
5425         snssai->sD->size = 3*sizeof(uint8_t);
5426         DU_ALLOC(snssai->sD->buf,snssai->sD->size);
5427         if(snssai->sD->buf == NULLP)
5428         {
5429                 return RFAILED;
5430         }
5431                 snssai->sD->buf[0] = 3;
5432                 snssai->sD->buf[1] = 6;
5433                 snssai->sD->buf[2] = 9;
5434    return ROK;
5435 }/*End of BuildSNSSAI*/
5436
5437 /*******************************************************************
5438  *
5439  * @brief Builds the flow map.
5440  *
5441  * @details
5442  *
5443  *    Function : BuildFlowsMap
5444  *
5445  *    Functionality: Constructs the flowmap For DRB list
5446  *
5447  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
5448  *
5449  * @return ROK     - success
5450  *         RFAILED - failure
5451  *
5452  * ****************************************************************/
5453 uint8_t BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap)
5454 {
5455         uint8_t  ret;
5456         uint8_t  idx;
5457         uint8_t  flowCnt;
5458         flowCnt = 1;
5459         flowMap->list.count = flowCnt;
5460         flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
5461         DU_ALLOC(flowMap->list.array,flowMap->list.size);
5462         if(flowMap->list.array == NULLP)
5463         {
5464                 return RFAILED;
5465         }
5466         for(idx=0; idx<flowCnt; idx++)
5467         {
5468                 DU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
5469                 if(flowMap->list.array[idx] == NULLP)
5470                 {
5471                    return RFAILED;
5472                 }
5473         }
5474         idx = 0;
5475         flowMap->list.array[idx]->qoSFlowIdentifier = 0;
5476         ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters);
5477         if(ret != ROK)
5478         {
5479                 return RFAILED;
5480         }
5481    return ROK;
5482 }/*End of BuildFlowsMap*/
5483
5484 /*******************************************************************
5485  *
5486  * @brief Builds the Uplink Tunnel Info
5487  *
5488  * @details
5489  *
5490  *    Function : BuildULTnlInfo
5491  *
5492  *    Functionality: Constructs the UL TnlInfo For DRB list
5493  *
5494  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
5495  *
5496  * @return ROK     - success
5497  *         RFAILED - failure
5498  *
5499  * ****************************************************************/
5500 uint8_t BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
5501 {
5502         uint8_t idx;
5503         uint8_t ulCnt;
5504         ulCnt = 1;
5505         ulInfo->list.count = ulCnt;
5506         ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
5507         DU_ALLOC(ulInfo->list.array,ulInfo->list.size);
5508         if(ulInfo->list.array == NULLP)
5509         {
5510                 return RFAILED;
5511         }
5512         for(idx=0; idx<ulCnt; idx++)
5513         {
5514                 DU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
5515                 if(ulInfo->list.array[idx] == NULLP)
5516                 {
5517                         return RFAILED;
5518                 }
5519         }
5520         idx = 0;
5521         ulInfo->list.array[idx]->uLUPTNLInformation.present = \
5522                                                                 UPTransportLayerInformation_PR_gTPTunnel;
5523         /*GTP TUNNEL*/
5524         DU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
5525                                 sizeof(GTPTunnel_t));
5526         if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
5527         {
5528                 return RFAILED;
5529         }
5530         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5531                 transportLayerAddress.size      = 4*sizeof(uint8_t);
5532    DU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5533                 transportLayerAddress.buf,ulInfo->list.array[idx]->\
5534                 uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
5535         if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5536                 transportLayerAddress.buf == NULLP)
5537         {
5538                 return RFAILED;
5539         }
5540         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5541                 transportLayerAddress.buf[0] = 4;
5542         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5543                 transportLayerAddress.buf[1] = 4;
5544         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5545                 transportLayerAddress.buf[2] = 4;
5546         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5547                 transportLayerAddress.buf[3] = 5;
5548         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5549                 transportLayerAddress.bits_unused = 0;
5550         /*GTP TEID*/
5551         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
5552                                         = 4 * sizeof(uint8_t);
5553         DU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5554                                 gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
5555                                 gTPTunnel->gTP_TEID.size);
5556         if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
5557                                 == NULLP)
5558         {
5559                 return RFAILED;
5560         }
5561         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5562                 gTP_TEID.buf[0] = 11;
5563         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5564                 gTP_TEID.buf[1] = 0;
5565         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5566                 gTP_TEID.buf[2] = 0;
5567         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
5568                 gTP_TEID.buf[3] = 1;
5569
5570    return ROK;
5571 }/*End of BuildULTnlInfo*/
5572
5573 /*******************************************************************
5574  *
5575  * @brief Builds DRBS to be setup
5576  *
5577  * @details
5578  *
5579  *    Function : BuildDRBSetup
5580  *
5581  *    Functionality: Constructs the DRB's for UESetReq
5582  *
5583  * @params[in] DRBs_ToBeSetup_List_t *drbSet
5584  *
5585  * @return ROK     - success
5586  *         RFAILED - failure
5587  *
5588  * ****************************************************************/
5589 uint8_t BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
5590 {
5591         uint8_t BuildQOSInforet;
5592         uint8_t BuildSNSSAIret;
5593         uint8_t BuildFlowsMapret;
5594         uint8_t idx;
5595         uint8_t drbCnt;
5596         DRBs_ToBeSetup_Item_t *drbSetItem;
5597         drbCnt = 1;
5598         drbSet->list.count = drbCnt;
5599         drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
5600         DU_ALLOC(drbSet->list.array,drbSet->list.size);
5601         if(drbSet->list.array == NULLP)
5602         {
5603                 return RFAILED;
5604         }
5605         for(idx=0; idx<drbCnt; idx++)
5606         {
5607                 DU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
5608                 if(drbSet->list.array[idx] == NULLP)
5609                 {
5610                         return RFAILED;
5611                 }
5612         }
5613         idx = 0;
5614         drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
5615         drbSet->list.array[idx]->criticality = Criticality_ignore;
5616         drbSet->list.array[idx]->value.present = \
5617                         DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
5618    drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
5619         /*dRBID*/
5620         drbSetItem->dRBID = 1;
5621         /*qoSInformation*/
5622         drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
5623         DU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
5624         if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
5625         {
5626                 return RFAILED;
5627         }
5628         drbSetItem->qoSInformation.choice.choice_extension->id = \
5629                                                         ProtocolIE_ID_id_DRB_Information;
5630         drbSetItem->qoSInformation.choice.choice_extension->criticality = \
5631                                                         Criticality_ignore;
5632         drbSetItem->qoSInformation.choice.choice_extension->value.present = \
5633                                                         QoSInformation_ExtIEs__value_PR_DRB_Information;
5634         BuildQOSInforet = BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
5635                                                         choice_extension->value.choice.DRB_Information.dRB_QoS);
5636         if(BuildQOSInforet != ROK)
5637         {
5638                 return RFAILED;
5639         }
5640         /*SNSSAI*/
5641         BuildSNSSAIret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
5642                                                         choice_extension->value.choice.DRB_Information.sNSSAI);
5643         if(BuildSNSSAIret != ROK)
5644         {
5645                 return RFAILED;
5646         }
5647         /*Flows mapped to DRB List*/
5648         BuildFlowsMapret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
5649                                 choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List);
5650         if(BuildFlowsMapret != ROK)
5651         {
5652                 return RFAILED;
5653         }
5654         /*ULUPTNLInformation To Be Setup List*/
5655    BuildULTnlInforet = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
5656         if(BuildULTnlInforet != ROK)
5657         {
5658                 return RFAILED;
5659         }
5660         /*RLCMode*/
5661         drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
5662
5663         /*UL Configuration*/
5664         DU_ALLOC(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
5665         if(drbSetItem->uLConfiguration == NULLP)
5666         {
5667            return RFAILED;
5668         }
5669         drbSetItem->uLConfiguration->uLUEConfiguration = ULUEConfiguration_no_data;
5670         return ROK;
5671 }/* End of BuildDRBSetup*/
5672 /*******************************************************************
5673 *
5674 * @brief Deallocating memory of function BuildAndSendUESetReq
5675 *
5676 * @details
5677 *
5678 *    Function : FreeNrcgi
5679 *
5680 *    Functionality: Deallocating memory for function BuildNrcgi
5681 *
5682 * @params[in] NRCGI_t *nrcgi
5683 *
5684 * @return void
5685 *
5686 *******************************************************************/
5687 void FreeNrcgi(NRCGI_t *nrcgi)
5688 {
5689         if(nrcgi->pLMN_Identity.buf != NULLP)
5690         {
5691              if(nrcgi->nRCellIdentity.buf != NULLP)
5692              {
5693            DU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
5694                   }
5695              DU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
5696         }
5697 }
5698 /*******************************************************************
5699 *
5700 * @brief  Deallocating memory of function BuildAndSendUESetReq
5701 *
5702 * @details
5703 *
5704 *    Function : FreeSplCellList
5705 *
5706 *    Functionality: Deallocating memory for function BuildSplCellList
5707 *
5708 * @params[in] SCell_ToBeSetup_List_t *spCellLst
5709 *
5710 * @return void
5711 *
5712 *
5713 * *****************************************************************/
5714 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
5715 {
5716     uint8_t  cellidx;
5717     if(spCellLst->list.array != NULLP)
5718          {
5719               for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
5720                         {
5721                             if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
5722                                  {
5723                                     FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
5724                                  }
5725                                  if(spCellLst->list.array[cellidx]!=NULLP)
5726                                  {
5727                                      DU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
5728                                  }
5729                         }
5730                         DU_FREE(spCellLst->list.array,spCellLst->list.size);
5731          }
5732 }
5733  /*******************************************************************
5734  *
5735  * @brief Deallocating memory of function BuildAndSendUESetReq
5736  *
5737  * @details
5738  *
5739  *    Function : FreeSRBSetup
5740  *
5741  *    Functionality: Deallocating memory for function BuildSRBSetup
5742  *
5743  * @params[in] SRBs_ToBeSetup_List_t *srbSet
5744  *
5745  * @return void
5746  *
5747  *
5748  * ******************************************************************/
5749 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
5750 {
5751     uint8_t srbidx;
5752          if(srbSet->list.array != NULLP)
5753          {
5754              for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
5755                   {
5756                       if(srbSet->list.array[srbidx]!=NULLP)
5757                                 {
5758                                     DU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
5759                                 }
5760                   }
5761                   DU_FREE(srbSet->list.array,srbSet->list.size);
5762          }
5763 }
5764  /*******************************************************************
5765   *
5766   * @brief Deallocating memory of function BuildAndSendUESetReq
5767   *
5768   * @details
5769   *
5770   *    Function : FreeQOSInfo
5771   *
5772   *    Functionality:  Deallocating memory for function BuildQOSInfo
5773   *
5774   * @params[in] QoSFlowLevelQoSParameters_t *drbQos
5775   *
5776   * @return void
5777   *
5778   * ****************************************************************/
5779 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
5780 {
5781     if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
5782          {
5783              if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
5784                   {
5785                       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
5786                                 {
5787                                     DU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
5788                                          sizeof(MaxDataBurstVolume_t));
5789                                 }
5790                                  DU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
5791                                  sizeof(AveragingWindow_t));
5792                   }
5793                   DU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
5794                   sizeof(NonDynamic5QIDescriptor_t));
5795          }
5796 }
5797  /*******************************************************************
5798   *
5799   * @brief Deallocating memory of function BuildAndSendUESetReq
5800   *
5801   * @details
5802   *
5803   *    Function : FreeULTnlInfo
5804   *
5805   *    Functionality:  Deallocating memory for function BuildULTnlInfo
5806   *
5807   * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
5808   *
5809   * @return void
5810   *
5811
5812  * ****************************************************************/
5813 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
5814 {
5815     uint8_t ulidx=0;
5816          if(ulInfo->list.array != NULLP)
5817          {
5818              for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
5819                   {
5820                       if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
5821                                 {
5822                                     if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
5823                                          {
5824                                              if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
5825                                                   transportLayerAddress.buf != NULLP)
5826                                                   {
5827                                                       if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
5828                                                                 !=NULLP)
5829                                                                 {
5830                                                                      DU_ALLOC(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
5831                                                                           gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
5832                                                                           gTPTunnel->gTP_TEID.size);
5833                                                                 }
5834                                                                 DU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
5835                                                                 transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
5836                                                                 uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
5837                                                   }
5838                                                   DU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
5839                                                   sizeof(GTPTunnel_t));
5840                                          }
5841                                 }
5842                                 if(ulInfo->list.array[ulidx]!=NULLP)
5843                                 {
5844                                     DU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
5845                                 }
5846                   }
5847                   DU_FREE(ulInfo->list.array,ulInfo->list.size);
5848          }
5849 }
5850 /*******************************************************************
5851  *
5852  * @brief Deallocating memory for BuildAndSendUESetReq
5853  *
5854  * @details
5855  *
5856  *    Function : FreeDRBSetup
5857  *
5858  *    Functionality:  Deallocating memory for BuildDRBSetup
5859  *
5860  * @params[in] DRBs_ToBeSetup_List_t *drbSet
5861  *
5862  * @return void
5863  *
5864  * ****************************************************************/
5865 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
5866 {
5867     DRBs_ToBeSetup_Item_t *drbSetItem;
5868          uint8_t  flowidx;
5869          uint8_t  drbidx;
5870     if(drbSet->list.array == NULLP)
5871          {
5872              for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
5873                   {
5874                        if(drbidx==0&&drbSet->list.array[drbidx] != NULLP)
5875                                  {
5876                                     drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
5877                                     if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
5878                                          {
5879                                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5880                                                          qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
5881                                                          {
5882                                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5883                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
5884                                                                   {
5885                                                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5886                                                                                  qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
5887                                                                                  {
5888                                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
5889                                                                                           {
5890                                                                                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
5891                                                                                                         {
5892                                                                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
5893                                                                                                                  {
5894                                                                                                                       if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
5895                                                                                                                                 flows_Mapped_To_DRB_List.list.array != NULLP)
5896                                                                                                                                 {
5897                                                                                                                                     for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
5898                                                                                                                                          flows_Mapped_To_DRB_List.list.count; flowidx++)
5899                                                                                                                                          {
5900                                                                                                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5901                                                                                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
5902                                                                                                                                                   {
5903                                                                                                                                                       if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5904                                                                                                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5905                                                                                                                                                                  qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
5906                                                                                                                                                                 {
5907                                                                                                                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5908                                                                                                                                                                           DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5909                                                                                                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
5910                                                                                                                                                                           {
5911                                                                                                                                                                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5912                                                                                                                                                                                         DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5913                                                                                                                                                                                         qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
5914                                                                                                                                                                                    {
5915                                                                                                                                                                                                  if((BuildULTnlInforet==ROK)&&(drbSetItem->uLConfiguration!=NULLP))
5916                                                                                                                                                                                                  {
5917                                                                                                                                                                                                      DU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
5918                                                                                                                                                                                                  }
5919                                                                                                                                                                                                  FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
5920                                                                          DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5921                                                                                                                                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5922                                                                                                                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
5923                                                                                                                                                                                                  sizeof(MaxDataBurstVolume_t));
5924                                                                                                                                                                                    }
5925                                                                                                                                                                                         DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5926                                                                                                                                                                                         DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5927                                                                                                                                                                                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
5928                                                                                                                                                                           }
5929                                                                                                                                                                           DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5930                                                                                                                                                                           DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
5931                                                                  qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
5932                                                                                                                                                                 }
5933                                                                                                                                                   }
5934                                                                                                                                                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5935                                                                                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
5936                                                                                                                                                   {
5937                                                                                                                                                       DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
5938                                                                                                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
5939                                                                                                                                                   }
5940                                                                                                                                          }
5941                                                                                                                                     DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
5942                                                                                                                                          flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
5943                                                                                                                                          choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
5944                                                                                                                                 }
5945                                                                                                                       DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
5946                                                                                                                         drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
5947                                                                                                                  }
5948                                                                                                                  DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
5949                                                                                                                  sizeof(OCTET_STRING_t));
5950                                                                                                         }
5951                                                                                                          DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
5952                                                                                                          drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
5953                                                                                           }
5954                                                                                           DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5955                                                                                      qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
5956                                                                                  }
5957                                                                        DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5958                                                                                  qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
5959                                                                   }
5960                                                              DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
5961                                                                   qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
5962                                                          }
5963                                                    DU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
5964                                          }
5965                                  }
5966                        if(drbSet->list.array[drbidx]!=NULLP)
5967                                  {
5968                                      DU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
5969                                 }
5970                   }
5971              DU_FREE(drbSet->list.array,drbSet->list.size);
5972          }
5973 }
5974 /*******************************************************************
5975  *
5976  * @brief Free the UE Setup Request
5977  *
5978  * @details
5979  *
5980  *    Function : FreeUESetReq
5981  *
5982  *    Functionality: Deallocate the memory of BuildUESetReq
5983  *
5984  * @params[in]  F1AP_PDU_t  *f1apMsg
5985  *
5986  * @return void
5987  *
5988  *
5989  * ****************************************************************/
5990  void FreeUESetReq(F1AP_PDU_t  *f1apMsg)
5991 {
5992     uint8_t idx=2;
5993     uint8_t ieId;
5994     UEContextSetupRequest_t       *ueSetReq;
5995
5996     if(f1apMsg != NULLP)
5997     {
5998                if(f1apMsg->choice.initiatingMessage != NULLP)
5999           {
6000                              ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
6001                    if(ueSetReq->protocolIEs.list.array != NULLP)
6002               {
6003                  if(ueSetReq->protocolIEs.list.array[idx])
6004                                           {
6005                                                if(Nrcgiret==ROK )
6006                       {
6007                                                               idx=6;
6008                                                               if(ueSetReq->protocolIEs.list.array[idx])
6009                                                                         {
6010                                 if(SplCellListret==ROK)
6011                                 {
6012                                                                                       idx++;
6013                                     if(ueSetReq->protocolIEs.list.array[idx])
6014                                                                                                 {
6015                                                                                                if(SRBSetupret == ROK)
6016                                         {
6017                                            idx=8;
6018                                                                                           FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
6019                                         }
6020                                         idx--;
6021                                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
6022                                                                                                 }
6023                                                                    }
6024                                 idx--;
6025                                 FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
6026                                                                         }
6027                       }
6028                       idx=2;
6029                       FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
6030                                                 }
6031                   for(ieId=0; ieId<ueSetReq->protocolIEs.list.count; ieId++)
6032                   {
6033                       if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
6034                       {
6035                            DU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
6036                        }
6037                   }
6038                    DU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
6039               }
6040               DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6041         }
6042         DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6043      }
6044  }
6045
6046 /*******************************************************************
6047  *
6048  * @brief Builds and sends the UE Setup Request
6049  *
6050  * @details
6051  *
6052  *    Function : BuildAndSendUESetReq
6053  *
6054  *    Functionality: Constructs the UE Setup Request and sends
6055  *                   it to the CU through SCTP.
6056  *
6057  * @params[in]
6058  *
6059  * @return ROK     - success
6060  *         RFAILED - failure
6061  *
6062  * ****************************************************************/
6063 uint8_t BuildAndSendUESetReq()
6064 {
6065
6066         uint8_t  elementCnt;
6067         uint8_t   idx;
6068         uint8_t   idx1;
6069         F1AP_PDU_t                                              *f1apMsg = NULL;
6070    UEContextSetupRequest_t                      *ueSetReq;
6071         asn_enc_rval_t                                          encRetVal;        /* Encoder return value */
6072    uint8_t ret= RFAILED;
6073         uint8_t ret1;
6074         while(true)
6075         {
6076             DU_LOG("\n F1AP : Building UE Context Setup Request\n");
6077
6078             DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6079             if(f1apMsg == NULLP)
6080             {
6081                     DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
6082                          break;
6083             }
6084
6085             f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6086             DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6087             if(f1apMsg->choice.initiatingMessage == NULLP)
6088             {
6089                      DU_LOG(" F1AP : Memory allocation for      F1AP-PDU failed");
6090                           break;
6091             }
6092
6093             f1apMsg->choice.initiatingMessage->procedureCode = \
6094                                                                                                         ProcedureCode_id_UEContextSetup;
6095             f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
6096             f1apMsg->choice.initiatingMessage->value.present = \
6097                                    InitiatingMessage__value_PR_UEContextSetupRequest;
6098             ueSetReq =
6099                   &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
6100             elementCnt = 9;
6101             ueSetReq->protocolIEs.list.count = elementCnt;
6102             ueSetReq->protocolIEs.list.size = \
6103                                                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *);
6104
6105             /* Initialize the UESetup members */
6106             DU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
6107
6108                  if(ueSetReq->protocolIEs.list.array == NULLP)
6109             {
6110                      DU_LOG(" F1AP : Memory allocation for UE Context SetupRequest failed");
6111                           break;
6112             }
6113
6114             for(idx1=0; idx1<elementCnt; idx1++)
6115             {
6116                      DU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
6117                      if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
6118                      {
6119                              break;
6120                      }
6121             }
6122
6123             idx = 0;
6124
6125             /*GNB CU UE F1AP ID*/
6126             ueSetReq->protocolIEs.list.array[idx]->id   = \
6127                                                                                  ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
6128          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_reject;
6129             ueSetReq->protocolIEs.list.array[idx]->value.present = \
6130                                                 UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
6131             ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
6132
6133             /*GNB DU UE F1AP ID*/
6134             idx++;
6135             ueSetReq->protocolIEs.list.array[idx]->id   = \
6136                                                                                  ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6137             ueSetReq->protocolIEs.list.array[idx]->criticality  =       Criticality_ignore;
6138             ueSetReq->protocolIEs.list.array[idx]->value.present = \
6139                                                 UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
6140             ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
6141
6142             /*Special Cell ID*/
6143             idx++;
6144             ueSetReq->protocolIEs.list.array[idx]->id   = \
6145                                                                                                          ProtocolIE_ID_id_SpCell_ID;
6146             ueSetReq->protocolIEs.list.array[idx]->criticality  =       Criticality_reject;
6147             ueSetReq->protocolIEs.list.array[idx]->value.present = \
6148                                                                 UEContextSetupRequestIEs__value_PR_NRCGI;
6149             Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
6150             if(Nrcgiret != ROK)
6151             {
6152                     break;
6153             }
6154
6155             /*Served Cell Index*/
6156             idx++;
6157             ueSetReq->protocolIEs.list.array[idx]->id   = \
6158                                                                                                  ProtocolIE_ID_id_ServCellIndex;
6159             ueSetReq->protocolIEs.list.array[idx]->criticality  =       Criticality_reject;
6160             ueSetReq->protocolIEs.list.array[idx]->value.present = \
6161                                                 UEContextSetupRequestIEs__value_PR_ServCellIndex;
6162             ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
6163             CELL_INDEX;
6164
6165             /*CellULConfigured*/
6166             idx++;
6167             ueSetReq->protocolIEs.list.array[idx]->id   = \
6168                                                                                         ProtocolIE_ID_id_SpCellULConfigured;
6169             ueSetReq->protocolIEs.list.array[idx]->criticality  =       Criticality_ignore;
6170             ueSetReq->protocolIEs.list.array[idx]->value.present = \
6171                                                                         UEContextSetupRequestIEs__value_PR_CellULConfigured;
6172             ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
6173                                                                                                                                                         CellULConfigured_none;
6174
6175
6176              /*CUtoDURRCContainer*/
6177              idx++;
6178              ueSetReq->protocolIEs.list.array[idx]->id  = \
6179                                                                                                   ProtocolIE_ID_id_CUtoDURRCInformation;
6180              ueSetReq->protocolIEs.list.array[idx]->criticality =       Criticality_reject;
6181              ueSetReq->protocolIEs.list.array[idx]->value.present = \
6182                                                 UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
6183
6184              /*Special Cells to be SetupList*/
6185              idx++;
6186              ueSetReq->protocolIEs.list.array[idx]->id  = \
6187                                                                                                   ProtocolIE_ID_id_SCell_ToBeSetup_List;
6188              ueSetReq->protocolIEs.list.array[idx]->criticality =       Criticality_ignore;
6189              ueSetReq->protocolIEs.list.array[idx]->value.present = \
6190                                                 UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
6191              SplCellListret = BuildSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
6192              if(SplCellListret != ROK)
6193              {
6194                      break;
6195              }
6196              /*SRBs To Be Setup List*/
6197              idx++;
6198              ueSetReq->protocolIEs.list.array[idx]->id  = \
6199                                                                                  ProtocolIE_ID_id_SRBs_ToBeSetup_List;
6200              ueSetReq->protocolIEs.list.array[idx]->criticality =       Criticality_reject;
6201              ueSetReq->protocolIEs.list.array[idx]->value.present = \
6202                                                 UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
6203              SRBSetupret =      BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
6204              if(SRBSetupret != ROK)
6205              {
6206                      break;
6207              }
6208              /*DRBs to Be Setup List*/
6209              idx++;
6210              ueSetReq->protocolIEs.list.array[idx]->id  = \
6211                                                                                  ProtocolIE_ID_id_DRBs_ToBeSetup_List;
6212              ueSetReq->protocolIEs.list.array[idx]->criticality =       Criticality_reject;
6213              ueSetReq->protocolIEs.list.array[idx]->value.present = \
6214                                                 UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
6215              ret1 = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
6216              if(ret1 != ROK)
6217              {
6218                      break;
6219              }
6220
6221              xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6222
6223              /* Encode the F1SetupRequest type as APER */
6224              memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6225              encBufSize = 0;
6226              encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
6227                         encBuf);
6228              /* Encode results */
6229              if(encRetVal.encoded == ENCODE_FAIL)
6230              {
6231                 DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
6232                                 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6233                       break;
6234              }
6235              else
6236              {
6237                       DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
6238                       for(int i=0; i< encBufSize; i++)
6239                       {
6240                         printf("%x",encBuf[i]);
6241                       }
6242             }
6243
6244             /* Sending  msg  */
6245             if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL)   !=      ROK)
6246             {
6247                 DU_LOG("\n F1AP : Sending       UE Context Setup Request Failed");
6248                       break;
6249             }
6250                  ret = ROK;
6251                  break;
6252    }
6253         FreeUESetReq(f1apMsg);
6254
6255         return ret;
6256 }/* End of BuildAndSendUESetReq*/
6257
6258 /*******************************************************************
6259 *
6260 * @brief Handles received F1AP message and sends back response
6261 *
6262 * @details
6263 *
6264 *    Function : F1APMsgHdlr
6265 *
6266 *    Functionality:
6267 *         - Decodes received F1AP control message
6268 *         - Prepares response message, encodes and sends to SCTP
6269 *
6270 * @params[in]
6271 * @return ROK     - success
6272 *         RFAILED - failure
6273 *
6274 * ****************************************************************/
6275 void F1APMsgHdlr(Buffer *mBuf)
6276 {
6277    int i;
6278    char *recvBuf;
6279    MsgLen copyCnt;
6280    MsgLen recvBufLen;
6281    F1AP_PDU_t *f1apMsg;
6282    asn_dec_rval_t rval; /* Decoder return value */
6283    F1AP_PDU_t f1apasnmsg ;
6284
6285    DU_LOG("\nF1AP : Received F1AP message buffer");
6286    ODU_PRINT_MSG(mBuf, 0,0);
6287
6288    /* Copy mBuf into char array to decode it */
6289    ODU_FIND_MSG_LEN(mBuf, &recvBufLen);
6290    DU_ALLOC(recvBuf, (Size)recvBufLen);
6291
6292    if(recvBuf == NULLP)
6293    {
6294       DU_LOG("\nF1AP : Memory allocation failed");
6295       return;
6296    }
6297    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
6298    {
6299       DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
6300       return;
6301    }
6302
6303    printf("\nF1AP : Received flat buffer to be decoded : ");
6304    for(i=0; i< recvBufLen; i++)
6305    {
6306         printf("%x",recvBuf[i]);
6307    }
6308
6309    /* Decoding flat buffer into F1AP messsage */
6310    f1apMsg = &f1apasnmsg;
6311    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
6312
6313    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
6314    DU_FREE(recvBuf, (Size)recvBufLen);
6315
6316    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
6317    {
6318       DU_LOG("\nF1AP : ASN decode failed");
6319       return;
6320    }
6321    printf("\n");
6322    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6323
6324    switch(f1apMsg->present)
6325    {
6326       case F1AP_PDU_PR_successfulOutcome:
6327       {
6328          switch(f1apMsg->choice.successfulOutcome->value.present)
6329          {
6330             case SuccessfulOutcome__value_PR_F1SetupResponse:
6331             {
6332 #ifndef ODU_TEST_STUB
6333                procF1SetupRsp(f1apMsg);
6334 #endif
6335                break;
6336             }
6337
6338             case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
6339             {
6340                procGNBDUCfgUpdAck(f1apMsg);
6341                break;
6342             }
6343
6344             default:
6345             {
6346                DU_LOG("\nF1AP : Invalid type of successful outcome [%d]", f1apMsg->choice.successfulOutcome->value.present);
6347                return;
6348             }
6349          }/* End of switch(successfulOutcome) */
6350          break;
6351       }
6352                 case F1AP_PDU_PR_initiatingMessage:
6353                 {
6354                         switch(f1apMsg->choice.initiatingMessage->value.present)
6355                         {
6356                                 case InitiatingMessage__value_PR_DLRRCMessageTransfer:
6357                                         {
6358                                                 procDlRrcMsgTrans(f1apMsg);
6359                                                 break;
6360                                         }
6361
6362                                 default:
6363                                         {
6364                                                 DU_LOG("\nF1AP : Invalid type of initiating message[%d]",
6365                                                                 f1apMsg->choice.initiatingMessage->value.present);
6366                                                 return;
6367                                         }
6368                         }/* End of switch(initiatingMessage) */
6369                         break;
6370                 }
6371
6372       default:
6373       {
6374          DU_LOG("\nF1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
6375          return;
6376       }
6377
6378    }/* End of switch(f1apMsg->present) */
6379
6380 } /* End of F1APMsgHdlr */
6381
6382 /**********************************************************************
6383   End of file
6384  **********************************************************************/