src/du_app/du_f1ap_msg_hdl.c

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