src/du_app/du_f1ap_msg_hdl.c

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