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