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