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
  27 extern char encBuf[ENC_BUF_MAX_LEN];
  28 extern DuCfgParams duCfgParam;
  29 S16 sctpSend(Buffer *mBuf, U8 itfType);
  30 /*******************************************************************
  31  *
  32  * @brief Builds Uplink Info for NR
  33  *
  34  * @details
  35  *
  36  *    Function : BuildULNRInfo
  37  *
  38  *    Functionality: Building NR Uplink Info
  39  *
  40  * @params[in] NRFreqInfo_t *ulnrfreq
  41  * @return ROK     - success
  42  *         RFAILED - failure
  43  *
  44  * ****************************************************************/
  45 S16 BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
  46 {
  47    U8 idx;
  48    idx = 0;
  49    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
  50                        fdd.ulNrFreqInfo.nrArfcn;
  51    ulnrfreq->freqBandListNr.list.count = 1;
  52    ulnrfreq->freqBandListNr.list.size = sizeof(struct FreqBandNrItem *);
  53    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
  54    if(ulnrfreq->freqBandListNr.list.array == NULLP)
  55    {
  56       RETVALUE(RFAILED);
  57    }
  58    DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(struct FreqBandNrItem));
  59    if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
  60    {
  61       DU_FREE(ulnrfreq->freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
  62       RETVALUE(RFAILED);
  63    }
  64       ulnrfreq->freqBandListNr.list.array[idx]->freqBandIndicatorNr = \
  65       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
  66       freqBand[0].nrFreqBand;
  67       ulnrfreq->freqBandListNr.list.array[idx]->supportedSULBandList.list.count = SUL_BAND_COUNT;
  68    return ROK;
  69 }
  70 /*******************************************************************
  71  *
  72  * @brief Builds Downlink NR Info
  73  *
  74  * @details
  75  *
  76  *    Function : BuildDLNRInfo
  77  *
  78  *    Functionality: Building Downlink NR Info
  79  *
  80  * @params[in] NRFreqInfo_t *dlnrfreq
  81  * @return ROK     - success
  82  *         RFAILED - failure
  83  *
  84  * ****************************************************************/
  85 S16 BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
  86 {
  87    U8 idx=0;
  88    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
  89                        fdd.dlNrFreqInfo.nrArfcn;
  90    dlnrfreq->freqBandListNr.list.count = 1;
  91    dlnrfreq->freqBandListNr.list.size = sizeof(struct FreqBandNrItem *);
  92    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
  93    if(dlnrfreq->freqBandListNr.list.array == NULLP)
  94    {
  95       RETVALUE(RFAILED);
  96    }
  97    DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(struct FreqBandNrItem));
  98    if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
  99    {
 100       DU_FREE(dlnrfreq->freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
 101       RETVALUE(RFAILED);
 102    }
 103    dlnrfreq->freqBandListNr.list.array[idx]->freqBandIndicatorNr = \
 104    duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 105    freqBand[0].nrFreqBand;
 106    dlnrfreq->freqBandListNr.list.array[idx]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 107    return ROK;
 108 }
 109
 110 /*******************************************************************
 111  *
 112  * @brief Builds Nrcgi
 113  *
 114  * @details
 115  *
 116  *    Function : BuildNrcgi
 117  *
 118  *    Functionality: Building the PLMN ID and NR Cell id
 119  *
 120  * @params[in] NRCGI_t *nrcgi
 121  * @return ROK     - success
 122  *         RFAILED - failure
 123  *
 124  * ****************************************************************/
 125 S16 BuildNrcgi(NRCGI_t *nrcgi)
 126 {
 127    S16 ret;
 128    U8 unused = 4;
 129    U8 byteSize = 5;
 130    U8 val = 16;
 131
 132    /* Allocate Buffer Memory */
 133    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(U8);
 134    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 135    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 136          &nrcgi->pLMN_Identity); // Building PLMN function
 137    if(ret != ROK)
 138    {
 139       return ret;
 140    }
 141    /*nrCellIdentity*/
 142    //ret = BuildNrCellId(&nrcgi->nRCellIdentity);
 143    nrcgi->nRCellIdentity.size = byteSize * sizeof(U8);
 144    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 145         if(nrcgi->nRCellIdentity.buf == NULLP)
 146    {
 147             return RFAILED;
 148    }
 149    ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
 150
 151    if(ret != ROK)
 152    {
 153       DU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 154       return ret;
 155    }
 156
 157    return ROK;
 158 }
 159 /*******************************************************************
 160  *
 161  * @brief Builds FiveGStac
 162  *
 163  * @details
 164  *
 165  *    Function : BuildFiveGSTac
 166  *
 167  *    Functionality: Building the FiveGSTac
 168  *
 169  * @params[in] OCTET_STRING_t *fivegsTac
 170  * @return ROK     - success
 171  *         RFAILED - failure
 172  *
 173  * ****************************************************************/
 174 S16 BuildFiveGSTac(Served_Cell_Information_t *servcell)
 175 {
 176    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 177    if(servcell->fiveGS_TAC == NULLP)
 178    {
 179       RETVALUE(RFAILED);
 180    }
 181    servcell->fiveGS_TAC->size = 3 * sizeof(U8);
 182    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 183          sizeof(servcell->fiveGS_TAC->size));
 184    if(servcell->fiveGS_TAC->buf == NULLP)
 185    {
 186       DU_FREE(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 187       RETVALUE(RFAILED);
 188    }
 189    servcell->fiveGS_TAC->buf[0] = 0;
 190    servcell->fiveGS_TAC->buf[1] = 0;
 191    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 192    return ROK;
 193 }
 194 /*******************************************************************
 195  *
 196  * @brief Builds NR Mode
 197  *
 198  * @details
 199  *
 200  *    Function : BuildNrMode
 201  *
 202  *    Functionality: Building the NR Mode
 203  *
 204  * @params[in] NR_Mode_Info_t *fdd
 205  * @return ROK     - success
 206  *         RFAILED - failure
 207  *
 208  * ****************************************************************/
 209 S16 BuildNrMode(NR_Mode_Info_t *mode)
 210 {
 211    S16 ret;
 212    /* FDD Mode */
 213    mode->present = NR_Mode_Info_PR_fDD;
 214    if(mode->present == NR_Mode_Info_PR_fDD)
 215    {
 216       DU_ALLOC(mode->choice.fDD,\
 217             sizeof(FDD_Info_t));
 218       if(mode->choice.fDD == NULLP)
 219       {
 220          RETVALUE(RFAILED);
 221       }
 222       ret = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 223       if(ret != ROK)
 224       {
 225          DU_FREE(mode->choice.fDD,\
 226                sizeof(FDD_Info_t));
 227          RETVALUE(RFAILED);
 228       }
 229       ret = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 230       if(ret != ROK)
 231       {
 232          DU_FREE(mode->choice.fDD,\
 233                sizeof(FDD_Info_t));
 234          DU_FREE(mode->choice.fDD->uL_NRFreqInfo.\
 235                freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
 236          DU_FREE(mode->choice.fDD->uL_NRFreqInfo.\
 237                freqBandListNr.list.array[0],sizeof(struct FreqBandNrItem));
 238          RETVALUE(RFAILED);
 239       }
 240    }
 241    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 242                                     duCfgParam.srvdCellLst[0].duCellInfo.\
 243                                     f1Mode.mode.fdd.ulTxBw.nrScs;
 244    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 245                                     duCfgParam.srvdCellLst[0].duCellInfo.\
 246                                     f1Mode.mode.fdd.ulTxBw.nrb;
 247
 248    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 249                                     duCfgParam.srvdCellLst[0].duCellInfo.\
 250                                     f1Mode.mode.fdd.dlTxBw.nrScs;
 251    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 252                                     duCfgParam.srvdCellLst[0].duCellInfo.\
 253                                     f1Mode.mode.fdd.dlTxBw.nrb;
 254    return ROK;
 255 }
 256 /*******************************************************************
 257  *
 258  * @brief Builds IE Extensions for Served PLMNs
 259  *
 260  * @details
 261  *
 262  *    Function : BuildExtensions
 263  *
 264  *    Functionality: Building the IE Extensions
 265  *
 266  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 267  * @return ROK     - success
 268  *         RFAILED - failure
 269  *
 270  * ****************************************************************/
 271 S16 BuildExtensions(struct ProtocolExtensionContainer_4624P3 **ieExtend)
 272 {
 273    U8 idx;
 274    U8 plmnidx;
 275    U8 extensionCnt=1;
 276    U8 extensionId;
 277    U8 sliceId;
 278    U8 sdId;
 279    DU_ALLOC(*ieExtend,\
 280          sizeof(struct ProtocolExtensionContainer_4624P3));
 281    if((*ieExtend) == NULLP)
 282    {
 283       RETVALUE(RFAILED);
 284    }
 285    (*ieExtend)->list.count = extensionCnt;
 286    (*ieExtend)->list.size = \
 287                             extensionCnt * sizeof(struct ServedPLMNs_ItemExtIEs *);
 288    DU_ALLOC((*ieExtend)->list.array,\
 289          extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
 290    if((*ieExtend)->list.array == NULLP)
 291    {
 292       DU_FREE((*ieExtend),sizeof(struct ProtocolExtensionContainer_4624P3));
 293       RETVALUE(RFAILED);
 294    }
 295    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 296    {
 297       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 298             sizeof(struct ServedPLMNs_ItemExtIEs));
 299       if((*ieExtend)->list.array[plmnidx] == NULLP)
 300       {
 301          for(extensionId=0 ; extensionId<plmnidx; extensionId++)
 302          {
 303             DU_FREE((*ieExtend)->list.array[extensionId],\
 304                   sizeof(struct ServedPLMNs_ItemExtIEs));
 305          }
 306          DU_FREE((*ieExtend)->list.array,\
 307                extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
 308          DU_FREE((*ieExtend),sizeof(struct ProtocolExtensionContainer_4624P3));
 309          RETVALUE(RFAILED);
 310       }
 311    }
 312       idx = 0;
 313       (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 314       (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 315       (*ieExtend)->list.array[idx]->extensionValue.present = \
 316                  ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 317       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 318       list.count = 1;
 319       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 320                  list.size = sizeof(SliceSupportItem_t *);
 321       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 322             list.array,sizeof(SliceSupportItem_t *));
 323       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 324             list.array == NULLP)
 325       {
 326          for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 327          {
 328             DU_FREE((*ieExtend)->list.array[plmnidx],\
 329                   sizeof(struct ServedPLMNs_ItemExtIEs));
 330          }
 331             DU_FREE((*ieExtend)->list.array,\
 332                   extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
 333             DU_FREE((*ieExtend),sizeof(struct ProtocolExtensionContainer_4624P3));
 334             RETVALUE(RFAILED);
 335
 336       }
 337       sliceId = 0;
 338       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 339             list.array[sliceId],sizeof(SliceSupportItem_t));
 340       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 341             list.array[sliceId] == NULLP)
 342       {
 343          DU_FREE((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 344                list.array,sizeof(SliceSupportItem_t *));
 345          for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 346          {
 347             DU_FREE((*ieExtend)->list.array[plmnidx],\
 348                   sizeof(struct ServedPLMNs_ItemExtIEs));
 349          }
 350          DU_FREE((*ieExtend)->list.array,\
 351                extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
 352          DU_FREE((*ieExtend),sizeof(struct ProtocolExtensionContainer_4624P3));
 353          RETVALUE(RFAILED);
 354       }
 355
 356       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 357          list.array[sliceId]->sNSSAI.sST.size = sizeof(U8);
 358       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 359             .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 360             extensionValue.choice.SliceSupportList.\
 361             list.array[sliceId]->sNSSAI.sST.size);
 362       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 363             .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
 364       {
 365          DU_FREE((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 366                list.array[sliceId],sizeof(SliceSupportItem_t));
 367          DU_FREE((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 368                list.array,sizeof(SliceSupportItem_t *));
 369          for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 370          {
 371             DU_FREE((*ieExtend)->list.array[plmnidx],\
 372                   sizeof(struct ServedPLMNs_ItemExtIEs));
 373          }
 374          DU_FREE((*ieExtend)->list.array,\
 375                extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
 376          DU_FREE((*ieExtend),sizeof(struct ProtocolExtensionContainer_4624P3));
 377          RETVALUE(RFAILED);
 378       }
 379       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 380          list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
 381       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 382             list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 383       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 384             list.array[sliceId]->sNSSAI.sD == NULLP)
 385       {
 386          DU_FREE((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 387                .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 388                extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.size);
 389          DU_FREE((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 390                list.array[sliceId],sizeof(SliceSupportItem_t));
 391          DU_FREE((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 392                list.array,sizeof(SliceSupportItem_t *));
 393          for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 394          {
 395             DU_FREE((*ieExtend)->list.array[plmnidx],\
 396                   sizeof(struct ServedPLMNs_ItemExtIEs));
 397          }
 398          DU_FREE((*ieExtend)->list.array,\
 399                extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
 400          DU_FREE((*ieExtend),sizeof(struct ProtocolExtensionContainer_4624P3));
 401          RETVALUE(RFAILED);
 402       }
 403       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 404          list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(U8);
 405       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 406             list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
 407             SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 408       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 409             list.array[sliceId]->sNSSAI.sD->buf == NULLP)
 410       {
 411          DU_FREE((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 412                list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 413          DU_FREE((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 414                .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->extensionValue.\
 415                choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.size);
 416          DU_FREE((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 417                list.array[sliceId],sizeof(SliceSupportItem_t));
 418          DU_FREE((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 419                list.array,sizeof(SliceSupportItem_t *));
 420          for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 421          {
 422             DU_FREE((*ieExtend)->list.array[plmnidx],\
 423                   sizeof(struct ServedPLMNs_ItemExtIEs));
 424          }
 425          DU_FREE((*ieExtend)->list.array,\
 426                extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
 427          DU_FREE((*ieExtend),sizeof(struct ProtocolExtensionContainer_4624P3));
 428          RETVALUE(RFAILED);
 429       }
 430       sdId = 0;
 431       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 432          list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
 433       sdId++;
 434       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 435          list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
 436       sdId++;
 437       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 438          list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
 439        return ROK;
 440 }
 441 /*******************************************************************
 442  *
 443  * @brief Builds Served PLMN
 444  *
 445  * @details
 446  *
 447  *    Function : BuildServedPlmn
 448  *
 449  *    Functionality: Building the Served PLMN
 450  *
 451  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 452  * @return ROK     - success
 453  *         RFAILED - failure
 454  *
 455  * ****************************************************************/
 456 S16  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 457 {
 458    S16 ret;
 459    U8  plmnidx;
 460    U8  servPlmnid;
 461    U8  servPlmnCnt=1;
 462    srvplmn->list.count = servPlmnCnt;
 463    srvplmn->list.size = \
 464                       servPlmnCnt*sizeof(struct ServedPLMNs_Item *);
 465    DU_ALLOC(srvplmn->list.array,\
 466          servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
 467    if(srvplmn->list.array == NULLP)
 468    {
 469       RETVALUE(RFAILED);
 470    }
 471
 472    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 473    {
 474       DU_ALLOC(srvplmn->list.array[plmnidx],\
 475             sizeof(struct ServedPLMNs_Item));
 476       if(srvplmn->list.array[plmnidx] == NULLP)
 477       {
 478          for(servPlmnid=0; servPlmnid<plmnidx;servPlmnid++)
 479          {
 480             DU_FREE(srvplmn->list.array[servPlmnid],\
 481                   sizeof(struct ServedPLMNs_Item));
 482          }
 483          DU_FREE(srvplmn->list.array,\
 484                sizeof(struct ServedPLMNs_Item *));
 485          RETVALUE(RFAILED);
 486       }
 487    }
 488    /* Allocate Memory to Buffer */
 489    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(U8);
 490    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 491    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 492          &srvplmn->list.array[0]->pLMN_Identity);
 493    if(ret!= ROK)
 494    {
 495       for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 496       {
 497          DU_FREE(srvplmn->list.array[plmnidx],\
 498                sizeof(struct ServedPLMNs_Item *));
 499       }
 500       DU_FREE(srvplmn->list.array,\
 501             sizeof(struct ServedPLMNs_Item *));
 502       RETVALUE(RFAILED);
 503    }
 504    ret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 505    if(ret != ROK)
 506    {
 507       DU_FREE(srvplmn->list.\
 508             array[0]->pLMN_Identity.buf,(Size)\
 509             srvplmn->list.array[0]->pLMN_Identity.size * sizeof(U8));
 510       for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 511       {
 512          DU_FREE(srvplmn->list.array[plmnidx],\
 513                sizeof(struct ServedPLMNs_Item *));
 514       }
 515       DU_FREE(srvplmn->list.array,\
 516             sizeof(struct ServedPLMNs_Item *));
 517       RETVALUE(RFAILED);
 518    }
 519    return ROK;
 520 }
 521 /*******************************************************************
 522  *
 523  * @brief Builds Served Cell List
 524  *
 525  * @details
 526  *
 527  *    Function : BuildServedCellList
 528  *
 529  *    Functionality: Building Served Cell List
 530  *
 531  * @params[in] PLMNID plmn
 532  * @return ROK     - success
 533  *         RFAILED - failure
 534  *
 535  * ****************************************************************/
 536
 537 S16 BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 538 {
 539    S16 ret;
 540    U8  idx;
 541    U8  plmnidx;
 542    U8  plmnId;
 543    U8  plmnCnt=1;
 544    U8  servPlmnCnt=1;
 545    U8  extensionCnt=1;
 546    U8  sliceId;
 547    U8  servId;
 548    U8  ieId;
 549    GNB_DU_Served_Cells_Item_t *srvCellItem;
 550
 551    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 552    duServedCell->list.count = plmnCnt;
 553    DU_ALLOC(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *));
 554    if(duServedCell->list.array == NULLP)
 555    {
 556       RETVALUE(RFAILED);
 557    }
 558    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 559    {
 560       DU_ALLOC(duServedCell->list.array[plmnidx],\
 561             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 562       if(duServedCell->list.array[plmnidx] == NULLP)
 563       {
 564          for(plmnId=0; plmnId<plmnidx ; plmnId++)
 565          {
 566             DU_FREE(duServedCell->list.array[plmnId],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 567          }
 568          DU_FREE(duServedCell->list.array,\
 569                plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t *));
 570          RETVALUE(RFAILED);
 571       }
 572    }
 573    idx = 0;
 574    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 575    duServedCell->list.array[idx]->criticality = Criticality_reject;
 576    duServedCell->list.array[idx]->value.present = \
 577                 GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 578    srvCellItem = \
 579            &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 580    /*nRCGI*/
 581    ret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 582    if(ret != ROK)
 583    {
 584       for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 585       {
 586          DU_FREE(duServedCell->list.array[plmnidx],\
 587                sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 588       }
 589       DU_FREE(duServedCell->list.array,\
 590             plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t *));
 591       RETVALUE(RFAILED);
 592    }
 593
 594    /*nRPCI*/
 595    srvCellItem->served_Cell_Information.nRPCI = \
 596                          duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 597
 598    /*fiveGS_TAC*/
 599    ret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 600    if(ret != ROK)
 601    {
 602       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
 603             srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(U8));
 604       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
 605             srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(U8));
 606       for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 607       {
 608          DU_FREE(duServedCell->list.array[plmnidx],\
 609                sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 610       }
 611       DU_FREE(duServedCell->list.array,\
 612             plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t *));
 613       RETVALUE(RFAILED);
 614    }
 615    /*Served PLMNs*/
 616    ret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 617    if(ret !=ROK)
 618    {
 619       DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
 620             sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
 621       DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,\
 622             sizeof(FiveGS_TAC_t));
 623       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
 624             srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(U8));
 625       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
 626             srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size  * sizeof(U8));
 627       for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 628       {
 629          DU_FREE(duServedCell->list.array[plmnidx],\
 630                sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 631       }
 632       DU_FREE(duServedCell->list.array,\
 633             plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t *));
 634       RETVALUE(RFAILED);
 635    }
 636    /*nR Mode Info with FDD*/
 637    ret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 638    sliceId = 0;
 639    ieId = 0;
 640    servId = 0;
 641    if(ret != ROK)
 642    {
 643       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 644          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 645          list.array[sliceId]->sNSSAI.sD->buf, srvCellItem->served_Cell_Information.servedPLMNs.\
 646          list.array[servId]->iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 647          list.array[sliceId]->sNSSAI.sD->size);
 648       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 649           iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 650           list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 651       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 652            iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList\
 653            .list.array[sliceId]->sNSSAI.sST.buf,sizeof(U8));
 654       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 655           iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 656           list.array[sliceId],sizeof(SliceSupportItem_t));
 657       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 658             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 659             list.array,sizeof(SliceSupportItem_t *));
 660       for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 661       {
 662          DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 663                array[servId]->iE_Extensions->list.array[plmnidx],\
 664                sizeof(struct ServedPLMNs_ItemExtIEs));
 665       }
 666       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 667             array[servId]->iE_Extensions->list.array,\
 668             extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
 669       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 670             array[servId]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
 671       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 672             array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
 673             servedPLMNs.list.array[servId]->pLMN_Identity.size * sizeof(U8));
 674       for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 675       {
 676          DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
 677                sizeof(struct ServedPLMNs_Item *));
 678       }
 679       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
 680             sizeof(struct ServedPLMNs_Item *));
 681       DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
 682             sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
 683       DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,\
 684             sizeof(FiveGS_TAC_t));
 685       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
 686             srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(U8));
 687       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
 688             srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(U8));
 689       for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 690       {
 691          DU_FREE(duServedCell->list.array[plmnidx],\
 692                sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 693       }
 694       DU_FREE(duServedCell->list.array,\
 695             plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t *));
 696       RETVALUE(RFAILED);
 697    }
 698
 699
 700    /*Measurement timing Config*/
 701    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 702       size = sizeof(U8);
 703    DU_ALLOC(srvCellItem->served_Cell_Information.\
 704          measurementTimingConfiguration.buf,sizeof(U8));
 705    if(srvCellItem->served_Cell_Information.\
 706          measurementTimingConfiguration.buf == NULLP)
 707    {
 708       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
 709          dL_NRFreqInfo.freqBandListNr.list.array[0],\
 710          sizeof(struct FreqBandNrItem));
 711       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
 712             dL_NRFreqInfo.freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
 713       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.\
 714             fDD->uL_NRFreqInfo.freqBandListNr.list.array[0],\
 715             sizeof(struct FreqBandNrItem));
 716       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
 717             uL_NRFreqInfo.freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
 718       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
 719             sizeof(FDD_Info_t));
 720       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 721          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 722          list.array[sliceId]->sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.\
 723          list.array[servId]->iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 724          list.array[sliceId]->sNSSAI.sD->size);
 725       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 726             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 727             list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 728       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 729            iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList\
 730            .list.array[sliceId]->sNSSAI.sST.buf,sizeof(U8));
 731       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 732           iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 733           list.array[sliceId],sizeof(SliceSupportItem_t));
 734       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 735             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 736             list.array,sizeof(SliceSupportItem_t *));
 737       for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 738       {
 739          DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 740                array[servId]->iE_Extensions->list.array[plmnidx],\
 741                sizeof(struct ServedPLMNs_ItemExtIEs));
 742       }
 743       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 744             array[servId]->iE_Extensions->list.array,\
 745             extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
 746       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 747             array[servId]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
 748       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 749             array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
 750             servedPLMNs.list.array[servId]->pLMN_Identity.size * sizeof(U8));
 751       for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 752       {
 753          DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
 754                sizeof(struct ServedPLMNs_Item *));
 755       }
 756       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
 757             sizeof(struct ServedPLMNs_Item *));
 758       DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
 759             sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
 760       DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,\
 761             sizeof(FiveGS_TAC_t));
 762       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
 763             srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(U8));
 764       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
 765             srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(U8));
 766       for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 767       {
 768          DU_FREE(duServedCell->list.array[plmnidx],\
 769                sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 770       }
 771       DU_FREE(duServedCell->list.array,\
 772             plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t *));
 773       RETVALUE(RFAILED);
 774    }
 775    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 776              duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 777
 778    /* GNB DU System Information */
 779    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 780                         sizeof(GNB_DU_System_Information_t));
 781    if(!srvCellItem->gNB_DU_System_Information)
 782         {
 783       DU_LOG("\nF1AP: Memory allocation failure for GNB_DU_System_Information");
 784                 return RFAILED;
 785         }
 786         /* MIB */
 787         srvCellItem->gNB_DU_System_Information->mIB_message.size =\
 788               strlen(( char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
 789         DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 790               srvCellItem->gNB_DU_System_Information->mIB_message.size);
 791    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 792         {
 793       DU_LOG("\nF1AP: Memory allocation failure for mIB message");
 794                 return RFAILED;
 795         }
 796    strcpy((char *)srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 797                         (char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
 798
 799    /* SIB1 */
 800         srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 801               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 802         DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 803               srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 804    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 805         {
 806       DU_LOG("\nF1AP: Memory allocation failure for SIB1 message");
 807                 return RFAILED;
 808         }
 809         for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 810         {
 811            srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 812       duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 813    }
 814    /* Free memory */
 815         DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,
 816                         srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 817         DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,
 818                         strlen((char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
 819    return ROK;
 820 }
 821 /*******************************************************************
 822  *
 823  * @brief Builds RRC Version
 824  *
 825  * @details
 826  *
 827  *    Function : BuildRrcVer
 828  *
 829  *    Functionality: Building RRC Version
 830  *
 831  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 832  * @return ROK     - success
 833  *         RFAILED - failure
 834  *
 835  * ****************************************************************/
 836 S16 BuildRrcVer(RRC_Version_t *rrcVer)
 837 {
 838    U8 rrcExt;
 839    U8 rrcLatest;
 840    rrcVer->latest_RRC_Version.size = sizeof(U8);
 841    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(U8));
 842    if(rrcVer->latest_RRC_Version.buf == NULLP)
 843    {
 844       RETVALUE(RFAILED);
 845    }
 846    rrcVer->latest_RRC_Version.buf[0] = 0;
 847    rrcVer->latest_RRC_Version.bits_unused = 5;
 848    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 849    if(rrcVer->iE_Extensions == NULLP)
 850    {
 851       DU_FREE(rrcVer->latest_RRC_Version.buf,sizeof(U8));
 852       RETVALUE(RFAILED);
 853    }
 854    rrcVer->iE_Extensions->list.count = 1;
 855    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 856    DU_ALLOC(rrcVer->iE_Extensions->list.array,\
 857          sizeof(struct RRC_Version_ExtIEs *));
 858    if(rrcVer->iE_Extensions->list.array == NULLP)
 859    {
 860       DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 861       DU_FREE(rrcVer->latest_RRC_Version.buf,sizeof(U8));
 862       RETVALUE(RFAILED);
 863    }
 864    rrcExt = 0;
 865    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 866          sizeof(struct RRC_Version_ExtIEs));
 867    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 868    {
 869       DU_FREE(rrcVer->iE_Extensions->list.array,\
 870             sizeof(struct RRC_Version_ExtIEs *));
 871       DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 872       DU_FREE(rrcVer->latest_RRC_Version.buf,sizeof(U8));
 873       RETVALUE(RFAILED);
 874    }
 875    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
 876                              ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 877    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
 878    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
 879               RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 880    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 881              .Latest_RRC_Version_Enhanced.size = 3*sizeof(U8);
 882    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 883          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 884          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 885    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 886           .Latest_RRC_Version_Enhanced.buf == NULLP)
 887    {
 888       DU_FREE(rrcVer->iE_Extensions->list.array[rrcExt],\
 889             sizeof(struct RRC_Version_ExtIEs));
 890       DU_FREE(rrcVer->iE_Extensions->list.array,\
 891             sizeof(struct RRC_Version_ExtIEs *));
 892       DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 893       DU_FREE(rrcVer->latest_RRC_Version.buf,sizeof(U8));
 894       RETVALUE(RFAILED);
 895    }
 896    rrcLatest = 0;
 897    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 898       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
 899    rrcLatest++;
 900    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 901       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
 902    rrcLatest++;
 903    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 904       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
 905    return ROK;
 906 }
 907 /*******************************************************************
 908 *
 909 * @brief Sends F1 msg over SCTP
 910 *
 911 * @details
 912 *
 913 *    Function : SendF1APMsg
 914 *
 915 *    Functionality: Sends F1 msg over SCTP
 916 *
 917 * @params[in] Region region
 918 *             Pool pool
 919 * @return ROK     - success
 920 *         RFAILED - failure
 921 *
 922 * ****************************************************************/
 923 S16 SendF1APMsg(Region region, Pool pool)
 924 {
 925    Buffer *mBuf;
 926
 927    if(SGetMsg(region, pool, &mBuf) == ROK)
 928    {
 929       if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK)
 930       {
 931          SPrntMsg(mBuf, 0,0);
 932
 933          if(sctpSend(mBuf, F1_INTERFACE) != ROK)
 934          {
 935             DU_LOG("\nF1AP : SCTP Send failed");
 936             SPutMsg(mBuf);
 937             RETVALUE(RFAILED);
 938          }
 939       }
 940       else
 941       {
 942          DU_LOG("\nF1AP : SAddPstMsgMult failed");
 943          SPutMsg(mBuf);
 944          RETVALUE(RFAILED);
 945       }
 946       SPutMsg(mBuf);
 947    }
 948    else
 949    {
 950       DU_LOG("\nF1AP : Failed to allocate memory");
 951       RETVALUE(RFAILED);
 952    }
 953    return ROK;
 954 } /* SendF1APMsg */
 955
 956
 957 /*******************************************************************
 958  *
 959  * @brief Builds and Send the F1SetupRequest
 960  *
 961  * @details
 962  *
 963  *    Function : BuildAndSendF1SetupReq
 964  *
 965  * Functionality:Fills the F1SetupRequest
 966  *
 967  * @return ROK     - success
 968  *         RFAILED - failure
 969  *
 970  ******************************************************************/
 971 S16 BuildAndSendF1SetupReq()
 972 {
 973    S16  ret;
 974    U8   idx;
 975    U8   ieId;
 976    U8   plmnidx;
 977    U8   servId;
 978    U8   sliceId;
 979    U8   elementCnt;
 980    U8   plmnCnt=1;
 981    U8   servPlmnCnt=1;
 982    U8   extensionCnt=1;
 983    F1AP_PDU_t                 *f1apMsg = NULL;
 984    F1SetupRequest_t           *f1SetupReq;
 985    GNB_DU_Served_Cells_List_t *duServedCell;
 986    GNB_DU_Served_Cells_Item_t *srvCellItem;
 987    RRC_Version_t              *rrcVer;
 988    asn_enc_rval_t             encRetVal;        /* Encoder return value */
 989    DU_LOG("\nF1AP : Building F1 Setup Request\n");
 990
 991    DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 992    if(f1apMsg == NULLP)
 993    {
 994       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 995       RETVALUE(RFAILED);
 996    }
 997
 998    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 999    DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1000    if(f1apMsg->choice.initiatingMessage == NULLP)
1001    {
1002       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
1003       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1004       RETVALUE(RFAILED);
1005    }
1006
1007    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1008    f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1009    f1apMsg->choice.initiatingMessage->value.present = \
1010                                     InitiatingMessage__value_PR_F1SetupRequest;
1011
1012    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1013
1014    elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1015
1016    f1SetupReq->protocolIEs.list.count = elementCnt;
1017    f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t *);
1018
1019    /* Initialize the F1Setup members */
1020    DU_ALLOC(f1SetupReq->protocolIEs.list.array, \
1021          elementCnt * sizeof(F1SetupRequestIEs_t *));
1022    if(f1SetupReq->protocolIEs.list.array == NULLP)
1023    {
1024       DU_LOG("\nF1AP : Memory allocation for F1RequestIEs failed");
1025       DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1026       DU_FREE(f1apMsg, (Size)sizeof(F1AP_PDU_t));
1027       RETVALUE(RFAILED);
1028    }
1029
1030    for(idx=0; idx<elementCnt; idx++)
1031    {
1032       DU_ALLOC(f1SetupReq->protocolIEs.list.array[idx],\
1033             sizeof(F1SetupRequestIEs_t));
1034       if(f1SetupReq->protocolIEs.list.array[idx] == NULLP)
1035       {
1036          for(ieId=0 ; ieId<idx ;ieId++)
1037          {
1038             DU_FREE(f1SetupReq->protocolIEs.list.array[ieId],\
1039                   sizeof(F1SetupRequestIEs_t));
1040          }
1041          DU_FREE(f1SetupReq->protocolIEs.list.array,\
1042                elementCnt * sizeof(F1SetupRequestIEs_t *));
1043          DU_FREE(f1apMsg->choice.initiatingMessage, \
1044                sizeof(InitiatingMessage_t));
1045          DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1046          RETVALUE(RFAILED);
1047       }
1048    }
1049
1050    idx = 0;
1051
1052    /*TransactionID*/
1053    f1SetupReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
1054    f1SetupReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1055    f1SetupReq->protocolIEs.list.array[idx]->value.present =\
1056                                     F1SetupRequestIEs__value_PR_TransactionID;
1057    f1SetupReq->protocolIEs.list.array[idx]->value.choice.TransactionID = \
1058                                                                    TRANS_ID;
1059
1060    /*DU ID*/
1061    idx++;
1062    f1SetupReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1063    f1SetupReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1064    f1SetupReq->protocolIEs.list.array[idx]->value.present = \
1065          F1SetupRequestIEs__value_PR_GNB_DU_ID;
1066    f1SetupReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_ID.size =\
1067                                                                     sizeof(U8);
1068
1069    DU_ALLOC(f1SetupReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_ID.buf,\
1070            sizeof(U8));
1071    if(f1SetupReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_ID.buf == \
1072          NULLP)
1073    {
1074       for(plmnidx=0; plmnidx<elementCnt; plmnidx++)
1075       {
1076          DU_FREE(f1SetupReq->protocolIEs.list.array[plmnidx], \
1077                sizeof(F1SetupRequestIEs_t));
1078       }
1079       DU_FREE(f1SetupReq->protocolIEs.list.array, \
1080             elementCnt * sizeof(F1SetupRequestIEs_t *));
1081       DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1082       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1083       RETVALUE(RFAILED);
1084    }
1085
1086    f1SetupReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_ID.buf[0] =\
1087                                                              duCfgParam.duId;
1088
1089    /*DU Name*/
1090    if(duCfgParam.duName != NULL)
1091    {
1092       idx++;
1093       f1SetupReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_DU_Name ;
1094       f1SetupReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
1095       f1SetupReq->protocolIEs.list.array[idx]->value.present = \
1096                                           F1SetupRequestIEs__value_PR_GNB_DU_Name;
1097       f1SetupReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_Name.size =\
1098                                                         sizeof(duCfgParam.duName);
1099
1100       DU_ALLOC(f1SetupReq->protocolIEs.list.array[idx]->value.choice.\
1101             GNB_DU_Name.buf, sizeof(duCfgParam.duName));
1102       if(f1SetupReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_Name.\
1103             buf == NULLP)
1104       {
1105          DU_FREE(f1SetupReq->protocolIEs.list.array[--idx]->value.choice.\
1106                GNB_DU_ID.buf, sizeof(U8));
1107          for(plmnidx=0; plmnidx<elementCnt; plmnidx++)
1108          {
1109             DU_FREE(f1SetupReq->protocolIEs.list.array[plmnidx], \
1110                   sizeof(F1SetupRequestIEs_t));
1111          }
1112          DU_FREE(f1SetupReq->protocolIEs.list.array,\
1113                elementCnt * sizeof(F1SetupRequestIEs_t *));
1114          DU_FREE(f1apMsg->choice.initiatingMessage, \
1115                sizeof(InitiatingMessage_t));
1116          DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1117          RETVALUE(RFAILED);
1118       }
1119
1120       strcpy((char*)f1SetupReq->protocolIEs.list.array[idx]->value.\
1121             choice.GNB_DU_Name.buf,
1122          (char*)&duCfgParam.duName);
1123    }
1124
1125    /*Served Cell list */
1126    idx++;
1127    f1SetupReq->protocolIEs.list.array[idx]->id = \
1128                                  ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1129    f1SetupReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1130    f1SetupReq->protocolIEs.list.array[idx]->value.present = \
1131                             F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1132    duServedCell = &f1SetupReq->protocolIEs.list.\
1133                   array[idx]->value.choice.GNB_DU_Served_Cells_List;
1134    ret = BuildServedCellList(duServedCell);
1135    srvCellItem =  &duServedCell->list.array[idx]->value. \
1136                        choice.GNB_DU_Served_Cells_Item;
1137    if(ret != ROK)
1138    {
1139       DU_FREE(f1SetupReq->protocolIEs.list.array[--idx]->value.\
1140             choice.GNB_DU_Name.buf, sizeof(duCfgParam.duName));
1141       DU_FREE(f1SetupReq->protocolIEs.list.array[--idx]->value.\
1142             choice.GNB_DU_ID.buf, sizeof(U8));
1143       for(plmnidx=0; plmnidx<elementCnt; idx++)
1144       {
1145          DU_FREE(f1SetupReq->protocolIEs.list.array[plmnidx],\
1146                sizeof(F1SetupRequestIEs_t));
1147       }
1148       DU_FREE(f1SetupReq->protocolIEs.list.array, \
1149             elementCnt * sizeof(F1SetupRequestIEs_t *));
1150       DU_FREE(f1apMsg->choice.initiatingMessage,\
1151             sizeof(InitiatingMessage_t));
1152       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1153    }
1154    /*RRC Version*/
1155    idx++;
1156    f1SetupReq->protocolIEs.list.array[idx]->id = \
1157                                   ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1158    f1SetupReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1159    f1SetupReq->protocolIEs.list.array[idx]->value.present = \
1160                                     F1SetupRequestIEs__value_PR_RRC_Version;
1161    rrcVer = &f1SetupReq->protocolIEs.list.array[idx]->value.choice.RRC_Version;
1162    ret = BuildRrcVer(rrcVer);
1163    ieId = 0;
1164    sliceId = 0;
1165    servId = 0;
1166    if(ret != ROK)
1167    {
1168       DU_FREE(srvCellItem->served_Cell_Information.\
1169             measurementTimingConfiguration.buf,sizeof(U8));
1170       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1171          dL_NRFreqInfo.freqBandListNr.list.array[0],\
1172          sizeof(struct FreqBandNrItem));
1173       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1174             dL_NRFreqInfo.freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
1175       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.\
1176             fDD->uL_NRFreqInfo.freqBandListNr.list.array[0],\
1177             sizeof(struct FreqBandNrItem));
1178       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1179             uL_NRFreqInfo.freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
1180       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
1181             sizeof(FDD_Info_t));
1182       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1183             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1184             list.array[sliceId]->sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.\
1185             list.array[servId]->iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1186             list.array[sliceId]->sNSSAI.sD->size);
1187       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1188             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1189             list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1190       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1191             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList\
1192             .list.array[sliceId]->sNSSAI.sST.buf,sizeof(U8));
1193       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1194             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1195             list.array[sliceId],sizeof(SliceSupportItem_t));
1196       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1197             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1198             list.array,sizeof(SliceSupportItem_t *));
1199       for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
1200       {
1201          DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1202                array[servId]->iE_Extensions->list.array[plmnidx],\
1203                sizeof(struct ServedPLMNs_ItemExtIEs));
1204       }
1205       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1206             array[servId]->iE_Extensions->list.array,\
1207             extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
1208       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1209             array[servId]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
1210       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1211             array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
1212             servedPLMNs.list.array[servId]->pLMN_Identity.size * sizeof(U8));
1213       for(plmnidx=0;plmnidx<servPlmnCnt; plmnidx++)
1214       {
1215          DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
1216                sizeof(struct ServedPLMNs_Item *));
1217       }
1218       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1219             sizeof(struct ServedPLMNs_Item *));
1220       DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1221             sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1222       DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,\
1223             sizeof(FiveGS_TAC_t));
1224       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1225             srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(U8));
1226       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1227             srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(U8));
1228       for(plmnidx=0; plmnidx<plmnCnt;plmnidx++)
1229       {
1230          DU_FREE(duServedCell->list.array[plmnidx],\
1231                sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1232       }
1233       DU_FREE(duServedCell->list.array,\
1234             plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t *));
1235       DU_FREE(f1SetupReq->protocolIEs.list.array[--idx]->value.\
1236             choice.GNB_DU_Name.buf, sizeof(duCfgParam.duName));
1237       DU_FREE(f1SetupReq->protocolIEs.list.array[--idx]->value.\
1238             choice.GNB_DU_ID.buf, sizeof(U8));
1239       for(plmnidx=0; plmnidx<elementCnt; plmnidx++)
1240       {
1241          DU_FREE(f1SetupReq->protocolIEs.list.array[plmnidx],\
1242                sizeof(F1SetupRequestIEs_t));
1243       }
1244       DU_FREE(f1SetupReq->protocolIEs.list.array,\
1245             elementCnt * sizeof(F1SetupRequestIEs_t *));
1246       DU_FREE(f1apMsg->choice.initiatingMessage,\
1247             sizeof(InitiatingMessage_t));
1248       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1249       RETVALUE(RFAILED);
1250    }
1251    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1252
1253    /* Encode the F1SetupRequest type as APER */
1254    cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
1255    encBufSize = 0;
1256    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1257          encBuf);
1258    /* Clean up */
1259 #if 0
1260       DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1261                    srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1262       DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1263                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1264       DU_FREE(srvCellItem->served_Cell_Information.\
1265             measurementTimingConfiguration.buf,sizeof(U8));
1266       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1267          dL_NRFreqInfo.freqBandListNr.list.array[0],\
1268          sizeof(struct FreqBandNrItem));
1269       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1270             dL_NRFreqInfo.freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
1271       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.\
1272             fDD->uL_NRFreqInfo.freqBandListNr.list.array[0],\
1273             sizeof(struct FreqBandNrItem));
1274       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1275             uL_NRFreqInfo.freqBandListNr.list.array,sizeof(struct FreqBandNrItem *));
1276       DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
1277             sizeof(FDD_Info_t));
1278       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1279             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1280             list.array[sliceId]->sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.\
1281             list.array[servId]->iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1282             list.array[sliceId]->sNSSAI.sD->size);
1283       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1284             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1285             list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1286       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1287             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList\
1288             .list.array[sliceId]->sNSSAI.sST.buf,sizeof(U8));
1289       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1290             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1291             list.array[sliceId],sizeof(SliceSupportItem_t));
1292       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1293             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1294             list.array,sizeof(SliceSupportItem_t *));
1295       for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
1296       {
1297          DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1298                array[servId]->iE_Extensions->list.array[plmnidx],\
1299                sizeof(struct ServedPLMNs_ItemExtIEs));
1300       }
1301       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1302             array[servId]->iE_Extensions->list.array,\
1303             extensionCnt*sizeof(struct ServedPLMNs_ItemExtIEs *));
1304       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1305             array[servId]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
1306       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1307             array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
1308             servedPLMNs.list.array[servId]->pLMN_Identity.size * sizeof(U8));
1309       for(plmnidx=0;plmnidx<servPlmnCnt; plmnidx++)
1310       {
1311          DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
1312                sizeof(struct ServedPLMNs_Item *));
1313       }
1314       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1315             sizeof(struct ServedPLMNs_Item *));
1316       DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1317             sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1318       DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,\
1319             sizeof(FiveGS_TAC_t));
1320       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1321             srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(U8));
1322       DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1323             srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(U8));
1324       for(plmnidx=0; plmnidx<plmnCnt;plmnidx++)
1325       {
1326          DU_FREE(duServedCell->list.array[plmnidx],\
1327                sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1328       }
1329       DU_FREE(duServedCell->list.array,\
1330             plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t *));
1331
1332 #endif
1333    if(duCfgParam.duName != NULL)
1334    {
1335       DU_FREE(f1SetupReq->protocolIEs.list.array[idx]->value.choice.\
1336             GNB_DU_Name.buf, sizeof(duCfgParam.duName));
1337    }
1338    DU_FREE(f1SetupReq->protocolIEs.list.array[--idx]->value.choice.GNB_DU_ID.\
1339          buf, sizeof(U8));
1340    for(idx=0; idx<elementCnt; idx++)
1341    {
1342       DU_FREE(f1SetupReq->protocolIEs.list.array[idx], sizeof(F1SetupRequestIEs_t));
1343    }
1344    DU_FREE(f1SetupReq->protocolIEs.list.array, elementCnt * sizeof(F1SetupRequestIEs_t *));
1345    DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1346    DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1347    /* Encode results */
1348    if(encRetVal.encoded == ENCODE_FAIL)
1349    {
1350            DU_LOG("\nF1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1351                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1352            RETVALUE(RFAILED);
1353    }
1354    else
1355    {
1356            DU_LOG("\nF1AP : Created APER encoded buffer for F1SetupRequest\n");
1357            for(int i=0; i< encBufSize; i++)
1358            {
1359                    printf("%x",encBuf[i]);
1360            }
1361    }
1362
1363    /* Sending msg */
1364    if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1365    {
1366            DU_LOG("\nF1AP : Sending F1 Setup request failed");
1367            RETVALUE(RFAILED);
1368    }
1369    return ROK;
1370 }/* End of BuildAndSendF1SetupReq */
1371
1372 /*******************************************************************
1373  *
1374  * @brief Builds and sends the DUConfigUpdate
1375  *
1376  * @details
1377  *
1378  *    Function : BuildAndSendDUConfigUpdate
1379  *
1380  *    Functionality: Constructs the DU Update message and sends
1381  *                   it to the CU through SCTP.
1382  *
1383  * @params[in] void **buf,Buffer to which encoded pattern is written into
1384  * @params[in] int *size,size of buffer
1385  *
1386  * @return ROK     - success
1387  *         RFAILED - failure
1388  *
1389  * ****************************************************************/
1390 S16 BuildAndSendDUConfigUpdate()
1391 {
1392    U8    idx,idy;
1393    U8    elementCnt,modifyCnt,servPlmnCnt,extensionCnt;
1394    asn_enc_rval_t encRetVal;      /* Encoder return value */
1395    F1AP_PDU_t *f1apDuCfg = NULL;
1396    GNBDUConfigurationUpdate_t *duCfgUpdate;
1397    Served_Cells_To_Modify_List_t  *cellsToModify;
1398    Served_Cells_To_Modify_Item_t *modifyItem;
1399    DU_LOG("\nF1AP : Building DU config update\n");
1400
1401    /* Allocate the memory for F1DuCfg */
1402    DU_ALLOC(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1403    if(f1apDuCfg == NULLP)
1404    {
1405            DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
1406            RETVALUE(RFAILED);
1407    }
1408
1409    f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
1410    DU_ALLOC(f1apDuCfg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1411    if(f1apDuCfg->choice.initiatingMessage == NULLP)
1412    {
1413       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
1414       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1415       RETVALUE(RFAILED);
1416    }
1417
1418    f1apDuCfg->choice.initiatingMessage->procedureCode = \
1419                                     ProcedureCode_id_gNBDUConfigurationUpdate;
1420    f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
1421    f1apDuCfg->choice.initiatingMessage->value.present = \
1422                          InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
1423    duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
1424                  choice.GNBDUConfigurationUpdate;
1425
1426    elementCnt = 3;
1427    duCfgUpdate->protocolIEs.list.count = elementCnt;
1428    duCfgUpdate->protocolIEs.list.size = \
1429                          elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *);
1430
1431    /* Initialize the F1Setup members */
1432    DU_ALLOC(duCfgUpdate->protocolIEs.list.array,\
1433          elementCnt*sizeof(GNBDUConfigurationUpdateIEs_t *));
1434    if(duCfgUpdate->protocolIEs.list.array == NULLP)
1435    {
1436       DU_LOG("F1AP : Memory allocation for F1RequestIEs failed");
1437       DU_FREE(f1apDuCfg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1438       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1439       RETVALUE(RFAILED);
1440    }
1441
1442    for(idx=0;idx<elementCnt;idx++)
1443    {
1444       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[idx], \
1445             sizeof(GNBDUConfigurationUpdateIEs_t));
1446       if(duCfgUpdate->protocolIEs.list.array[idx] == NULLP)
1447       {
1448          DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1449                elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1450          DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1451                (Size)sizeof(InitiatingMessage_t));
1452          DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1453          RETVALUE(RFAILED);
1454       }
1455    }
1456
1457    /*TransactionID*/
1458    idx = 0;
1459    duCfgUpdate->protocolIEs.list.array[idx]->id = \
1460                                                 ProtocolIE_ID_id_TransactionID;
1461    duCfgUpdate->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1462    duCfgUpdate->protocolIEs.list.array[idx]->value.present = \
1463                            GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
1464    duCfgUpdate->protocolIEs.list.array[idx]->value.choice.TransactionID = \
1465                                                                       TRANS_ID;
1466 #if 1
1467    /*Served Cell to Modify */
1468    idx++;
1469    duCfgUpdate->protocolIEs.list.array[idx]->id = \
1470                                   ProtocolIE_ID_id_Served_Cells_To_Modify_List;
1471    duCfgUpdate->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1472    duCfgUpdate->protocolIEs.list.array[idx]->value.present = \
1473               GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
1474    cellsToModify = &duCfgUpdate->protocolIEs.list.array[1]->value.choice.\
1475                    Served_Cells_To_Modify_List;
1476    modifyCnt = 1;
1477    cellsToModify->list.count = modifyCnt;
1478    cellsToModify->list.size = \
1479                       modifyCnt*sizeof(struct Served_Cells_To_Modify_ItemIEs *);
1480    DU_ALLOC(cellsToModify->list.array,modifyCnt*\
1481          sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1482    if(cellsToModify->list.array == NULLP)
1483    {
1484       for(idy=0;idy<elementCnt;idy++)
1485       {
1486          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1487                sizeof(GNBDUConfigurationUpdateIEs_t));
1488       }
1489          DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1490                elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1491          DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1492                (Size)sizeof(InitiatingMessage_t));
1493          DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1494          RETVALUE(RFAILED);
1495
1496    }
1497    for(idy=0; idy<modifyCnt ;idy++)
1498    {
1499       DU_ALLOC(cellsToModify->list.array[idy],\
1500             sizeof(struct Served_Cells_To_Modify_ItemIEs));
1501       if(cellsToModify->list.array[idy] == NULLP)
1502       {
1503          DU_FREE(cellsToModify->list.array,modifyCnt*\
1504                sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1505          for(idy=0;idy<elementCnt;idy++)
1506          {
1507             DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1508                   sizeof(GNBDUConfigurationUpdateIEs_t));
1509          }
1510          DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1511                elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1512          DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1513                (Size)sizeof(InitiatingMessage_t));
1514          DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1515          RETVALUE(RFAILED);
1516       }
1517    }
1518    cellsToModify->list.array[0]->id = \
1519                                   ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
1520    cellsToModify->list.array[0]->criticality = Criticality_reject;
1521    cellsToModify->list.array[0]->value.present = \
1522            Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
1523    modifyItem=&cellsToModify->list.array[0]->value.choice.\
1524               Served_Cells_To_Modify_Item;
1525
1526    /*pLMN_Identity*/
1527    modifyItem->oldNRCGI.pLMN_Identity.size = 3;
1528    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf, 3*sizeof(uint8_t));
1529    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
1530    {
1531       for(idy=0; idy<modifyCnt ;idy++)
1532       {
1533          DU_FREE(cellsToModify->list.array[idy],\
1534                sizeof(struct Served_Cells_To_Modify_ItemIEs));
1535          DU_FREE(cellsToModify->list.array,modifyCnt*\
1536                sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1537          for(idy=0;idy<elementCnt;idy++)
1538          {
1539             DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1540                   sizeof(GNBDUConfigurationUpdateIEs_t));
1541          }
1542          DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1543                elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1544          DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1545                (Size)sizeof(InitiatingMessage_t));
1546          DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1547          RETVALUE(RFAILED);
1548       }
1549    }
1550    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1551          &modifyItem->oldNRCGI.pLMN_Identity);
1552    /*nRCellIdentity*/
1553    modifyItem->oldNRCGI.nRCellIdentity.size = 5;
1554    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1555          modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1556    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
1557    {
1558       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1559       DU_FREE(cellsToModify->list.array[idy],\
1560             sizeof(struct Served_Cells_To_Modify_ItemIEs));
1561       DU_FREE(cellsToModify->list.array,modifyCnt*\
1562             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1563       for(idy=0;idy<elementCnt;idy++)
1564       {
1565          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1566                sizeof(GNBDUConfigurationUpdateIEs_t));
1567       }
1568       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1569             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1570       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1571             (Size)sizeof(InitiatingMessage_t));
1572       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1573       RETVALUE(RFAILED);
1574    }
1575    for (int tmp = 0 ; tmp < modifyItem->oldNRCGI.nRCellIdentity.size-1 ; tmp++)
1576    {
1577       modifyItem->oldNRCGI.nRCellIdentity.buf[tmp] = 0;
1578    }
1579    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
1580    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
1581    /*pLMN_Identity*/
1582    /*nRCGI*/
1583    modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size = 3;
1584    DU_ALLOC(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1585          3*sizeof(U8));
1586    if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf == NULLP)
1587    {
1588       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1589             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1590       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1591       DU_FREE(cellsToModify->list.array[idy],\
1592             sizeof(struct Served_Cells_To_Modify_ItemIEs));
1593       DU_FREE(cellsToModify->list.array,modifyCnt*\
1594             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1595       for(idy=0;idy<elementCnt;idy++)
1596       {
1597          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1598                sizeof(GNBDUConfigurationUpdateIEs_t));
1599       }
1600       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1601             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1602       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1603             (Size)sizeof(InitiatingMessage_t));
1604       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1605       RETVALUE(RFAILED);
1606    }
1607    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1608          &modifyItem->served_Cell_Information.nRCGI.pLMN_Identity);
1609    modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size = 5;
1610    DU_ALLOC(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1611          5*sizeof(uint8_t));
1612    if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf == NULLP)
1613    {
1614       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1615             3*sizeof(U8));
1616       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1617             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1618       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1619       DU_FREE(cellsToModify->list.array[idy],\
1620             sizeof(struct Served_Cells_To_Modify_ItemIEs));
1621       DU_FREE(cellsToModify->list.array,modifyCnt*\
1622             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1623       for(idy=0;idy<elementCnt;idy++)
1624       {
1625          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1626                sizeof(GNBDUConfigurationUpdateIEs_t));
1627       }
1628       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1629             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1630       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1631             (Size)sizeof(InitiatingMessage_t));
1632       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1633       RETVALUE(RFAILED);
1634    }
1635    for (int tmp = 0 ; tmp < modifyItem->served_Cell_Information.\
1636          nRCGI.nRCellIdentity.size-1 ; tmp++)
1637    {
1638       modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf[tmp] = 0;
1639    }
1640    modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf[4] = 16;
1641    modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.bits_unused = 4;
1642
1643    /*nRPCI*/
1644    modifyItem->served_Cell_Information.nRPCI = \
1645                            duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1646
1647    /*servedPLMNs*/
1648    servPlmnCnt = 1;
1649    modifyItem->served_Cell_Information.servedPLMNs.list.count = servPlmnCnt;
1650    modifyItem->served_Cell_Information.servedPLMNs.list.size = \
1651                                 servPlmnCnt*sizeof(struct ServedPLMNs_Item *);
1652    DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1653          servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
1654    if(modifyItem->served_Cell_Information.servedPLMNs.list.array == NULLP)
1655    {
1656       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1657             5*sizeof(uint8_t));
1658       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1659             3*sizeof(U8));
1660       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1661             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1662       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1663       DU_FREE(cellsToModify->list.array[idy],\
1664             sizeof(struct Served_Cells_To_Modify_ItemIEs));
1665       DU_FREE(cellsToModify->list.array,modifyCnt*\
1666             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1667       for(idy=0;idy<elementCnt;idy++)
1668       {
1669          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1670                sizeof(GNBDUConfigurationUpdateIEs_t));
1671       }
1672       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1673             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1674       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1675             (Size)sizeof(InitiatingMessage_t));
1676       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1677       RETVALUE(RFAILED);
1678    }
1679    for(idy=0;idy<servPlmnCnt;idy++)
1680    {
1681       DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
1682             servPlmnCnt*sizeof(struct ServedPLMNs_Item));
1683       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy] == NULLP)
1684       {
1685          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1686                servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
1687          DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1688                5*sizeof(uint8_t));
1689          DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1690                3*sizeof(U8));
1691          DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1692                modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1693          DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1694          DU_FREE(cellsToModify->list.array[idy],\
1695                sizeof(struct Served_Cells_To_Modify_ItemIEs));
1696          DU_FREE(cellsToModify->list.array,modifyCnt*\
1697                sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1698          for(idy=0;idy<elementCnt;idy++)
1699          {
1700             DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1701                   sizeof(GNBDUConfigurationUpdateIEs_t));
1702          }
1703          DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1704                elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1705          DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1706                (Size)sizeof(InitiatingMessage_t));
1707          DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1708          RETVALUE(RFAILED);
1709       }
1710    }
1711    modifyItem->served_Cell_Information.servedPLMNs.list.\
1712       array[0]->pLMN_Identity.size = 3;
1713    DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
1714          array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
1715    if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1716          array[0]->pLMN_Identity.buf == NULLP)
1717    {
1718       for(idy=0;idy<servPlmnCnt;idy++)
1719       {
1720          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
1721                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
1722       }
1723       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1724             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
1725       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1726             5*sizeof(uint8_t));
1727       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1728             3*sizeof(U8));
1729       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1730             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1731       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1732       DU_FREE(cellsToModify->list.array[idy],\
1733             sizeof(struct Served_Cells_To_Modify_ItemIEs));
1734       DU_FREE(cellsToModify->list.array,modifyCnt*\
1735             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1736       for(idy=0;idy<elementCnt;idy++)
1737       {
1738          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1739                sizeof(GNBDUConfigurationUpdateIEs_t));
1740       }
1741       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1742             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1743       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1744             (Size)sizeof(InitiatingMessage_t));
1745       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1746       RETVALUE(RFAILED);
1747    }
1748    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
1749          &modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->pLMN_Identity);
1750    DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
1751        array[0]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
1752    if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1753          array[0]->iE_Extensions == NULLP)
1754    {
1755       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1756             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
1757       for(idy=0;idy<servPlmnCnt;idy++)
1758       {
1759          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
1760                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
1761       }
1762       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1763             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
1764       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1765             5*sizeof(uint8_t));
1766       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1767             3*sizeof(U8));
1768       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1769             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1770       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1771       DU_FREE(cellsToModify->list.array[idy],\
1772             sizeof(struct Served_Cells_To_Modify_ItemIEs));
1773       DU_FREE(cellsToModify->list.array,modifyCnt*\
1774             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1775       for(idy=0;idy<elementCnt;idy++)
1776       {
1777          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1778                sizeof(GNBDUConfigurationUpdateIEs_t));
1779       }
1780       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1781             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1782       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1783             (Size)sizeof(InitiatingMessage_t));
1784       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1785       RETVALUE(RFAILED);
1786    }
1787    extensionCnt=1;
1788    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1789       iE_Extensions->list.count = extensionCnt;
1790    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1791       iE_Extensions->list.size = extensionCnt * \
1792       sizeof(struct ServedPLMNs_ItemExtIEs *);
1793    DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
1794          array[0]->iE_Extensions->list.array,extensionCnt*\
1795          sizeof(struct ServedPLMNs_ItemExtIEs *));
1796    if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1797          array[0]->iE_Extensions->list.array == NULLP)
1798    {
1799       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1800             array[0]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
1801       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1802             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
1803       for(idy=0;idy<servPlmnCnt;idy++)
1804       {
1805          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
1806                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
1807       }
1808       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1809             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
1810       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1811             5*sizeof(uint8_t));
1812       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1813             3*sizeof(U8));
1814       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1815             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1816       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1817       DU_FREE(cellsToModify->list.array[idy],\
1818             sizeof(struct Served_Cells_To_Modify_ItemIEs));
1819       DU_FREE(cellsToModify->list.array,modifyCnt*\
1820             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1821       for(idy=0;idy<elementCnt;idy++)
1822       {
1823          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1824                sizeof(GNBDUConfigurationUpdateIEs_t));
1825       }
1826       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1827             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1828       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1829             (Size)sizeof(InitiatingMessage_t));
1830       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1831       RETVALUE(RFAILED);
1832    }
1833    for(idy=0;idy<extensionCnt;idy++)
1834    {
1835       DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
1836             array[0]->iE_Extensions->list.array[idy],\
1837             sizeof(struct ServedPLMNs_ItemExtIEs));
1838       if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1839             array[0]->iE_Extensions->list.array[idy] == NULLP)
1840       {
1841          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1842                array[0]->iE_Extensions->list.array,extensionCnt*\
1843                sizeof(struct ServedPLMNs_ItemExtIEs *));
1844          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1845                array[0]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
1846          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1847                array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
1848          for(idy=0;idy<servPlmnCnt;idy++)
1849          {
1850             DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
1851                   servPlmnCnt*sizeof(struct ServedPLMNs_Item));
1852          }
1853          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1854                servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
1855          DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1856                5*sizeof(uint8_t));
1857          DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1858                3*sizeof(U8));
1859          DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1860                modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1861          DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1862          DU_FREE(cellsToModify->list.array[idy],\
1863                sizeof(struct Served_Cells_To_Modify_ItemIEs));
1864          DU_FREE(cellsToModify->list.array,modifyCnt*\
1865                sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1866          for(idy=0;idy<elementCnt;idy++)
1867          {
1868             DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1869                   sizeof(GNBDUConfigurationUpdateIEs_t));
1870          }
1871          DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1872                elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1873          DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1874                (Size)sizeof(InitiatingMessage_t));
1875          DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1876          RETVALUE(RFAILED);
1877       }
1878    }
1879    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1880       iE_Extensions->list.array[0]->id = ProtocolIE_ID_id_TAISliceSupportList;
1881    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1882       iE_Extensions->list.array[0]->criticality = Criticality_ignore;
1883    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1884       iE_Extensions->list.array[0]->extensionValue.present = \
1885       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1886    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1887       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1888       list.count = 1;
1889    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1890       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1891       list.size = sizeof(SliceSupportItem_t *);
1892    DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1893          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1894          list.array,sizeof( SliceSupportItem_t *));
1895    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1896          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1897          list.array == NULLP)
1898    {
1899       for(idy=0;idy<extensionCnt;idy++)
1900       {
1901          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1902                array[0]->iE_Extensions->list.array[idy],\
1903                sizeof(struct ServedPLMNs_ItemExtIEs));
1904       }
1905       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1906             array[0]->iE_Extensions->list.array,extensionCnt*\
1907             sizeof(struct ServedPLMNs_ItemExtIEs *));
1908       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1909             array[0]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
1910       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1911             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
1912       for(idy=0;idy<servPlmnCnt;idy++)
1913       {
1914          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
1915                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
1916       }
1917       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1918             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
1919       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1920             5*sizeof(uint8_t));
1921       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1922             3*sizeof(U8));
1923       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1924             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1925       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1926       DU_FREE(cellsToModify->list.array[idy],\
1927             sizeof(struct Served_Cells_To_Modify_ItemIEs));
1928       DU_FREE(cellsToModify->list.array,modifyCnt*\
1929             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1930       for(idy=0;idy<elementCnt;idy++)
1931       {
1932          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1933                sizeof(GNBDUConfigurationUpdateIEs_t));
1934       }
1935       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1936             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1937       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1938             (Size)sizeof(InitiatingMessage_t));
1939       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1940       RETVALUE(RFAILED);
1941    }
1942    DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1943          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1944          list.array[0],sizeof( SliceSupportItem_t));
1945    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1946          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1947          list.array[0] == NULLP)
1948    {
1949       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1950             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1951             list.array,sizeof( SliceSupportItem_t *));
1952       for(idy=0;idy<extensionCnt;idy++)
1953       {
1954          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1955                array[0]->iE_Extensions->list.array[idy],\
1956                sizeof(struct ServedPLMNs_ItemExtIEs));
1957       }
1958       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1959             array[0]->iE_Extensions->list.array,extensionCnt*\
1960             sizeof(struct ServedPLMNs_ItemExtIEs *));
1961       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1962             array[0]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
1963       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1964             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
1965       for(idy=0;idy<servPlmnCnt;idy++)
1966       {
1967          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
1968                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
1969       }
1970       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1971             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
1972       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1973             5*sizeof(uint8_t));
1974       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1975             3*sizeof(U8));
1976       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1977             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
1978       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
1979       DU_FREE(cellsToModify->list.array[idy],\
1980             sizeof(struct Served_Cells_To_Modify_ItemIEs));
1981       DU_FREE(cellsToModify->list.array,modifyCnt*\
1982             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
1983       for(idy=0;idy<elementCnt;idy++)
1984       {
1985          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
1986                sizeof(GNBDUConfigurationUpdateIEs_t));
1987       }
1988       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
1989             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
1990       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
1991             (Size)sizeof(InitiatingMessage_t));
1992       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
1993       RETVALUE(RFAILED);
1994    }
1995    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1996       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1997       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
1998    DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
1999          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2000          list.array[0]->sNSSAI.sST.buf,sizeof(uint8_t));
2001    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2002          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2003          list.array[0]->sNSSAI.sST.buf == NULLP)
2004    {
2005       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2006             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2007             list.array[0],sizeof( SliceSupportItem_t));
2008       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2009             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2010             list.array,sizeof( SliceSupportItem_t *));
2011       for(idy=0;idy<extensionCnt;idy++)
2012       {
2013          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2014                array[0]->iE_Extensions->list.array[idy],\
2015                sizeof(struct ServedPLMNs_ItemExtIEs));
2016       }
2017       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2018             array[0]->iE_Extensions->list.array,extensionCnt*\
2019             sizeof(struct ServedPLMNs_ItemExtIEs *));
2020       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2021             array[0]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
2022       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2023             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
2024       for(idy=0;idy<servPlmnCnt;idy++)
2025       {
2026          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
2027                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
2028       }
2029       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2030             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
2031       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2032             5*sizeof(uint8_t));
2033       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2034             3*sizeof(U8));
2035       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2036             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
2037       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
2038       DU_FREE(cellsToModify->list.array[idy],\
2039             sizeof(struct Served_Cells_To_Modify_ItemIEs));
2040       DU_FREE(cellsToModify->list.array,modifyCnt*\
2041             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
2042       for(idy=0;idy<elementCnt;idy++)
2043       {
2044          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
2045                sizeof(GNBDUConfigurationUpdateIEs_t));
2046       }
2047       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
2048             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2049       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
2050             (Size)sizeof(InitiatingMessage_t));
2051       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2052       RETVALUE(RFAILED);
2053    }
2054    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2055       iE_Extensions->list.array[0]->extensionValue. choice.SliceSupportList.\
2056       list.array[0]->sNSSAI.sST.buf[0] = 3;
2057    DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2058          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2059          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2060    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2061          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2062          list.array[0]->sNSSAI.sD == NULLP)
2063    {
2064       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2065             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2066             list.array[0]->sNSSAI.sST.buf,sizeof(uint8_t));
2067       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2068             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2069             list.array[0],sizeof( SliceSupportItem_t));
2070       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2071             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2072             list.array,sizeof( SliceSupportItem_t *));
2073       for(idy=0;idy<extensionCnt;idy++)
2074       {
2075          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2076                array[0]->iE_Extensions->list.array[idy],\
2077                sizeof(struct ServedPLMNs_ItemExtIEs));
2078       }
2079       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2080             array[0]->iE_Extensions->list.array,extensionCnt*\
2081             sizeof(struct ServedPLMNs_ItemExtIEs *));
2082       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2083             array[0]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
2084       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2085             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
2086       for(idy=0;idy<servPlmnCnt;idy++)
2087       {
2088          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
2089                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
2090       }
2091       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2092             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
2093       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2094             5*sizeof(uint8_t));
2095       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2096             3*sizeof(U8));
2097       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2098             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
2099       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
2100       DU_FREE(cellsToModify->list.array[idy],\
2101             sizeof(struct Served_Cells_To_Modify_ItemIEs));
2102       DU_FREE(cellsToModify->list.array,modifyCnt*\
2103             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
2104       for(idy=0;idy<elementCnt;idy++)
2105       {
2106          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
2107                sizeof(GNBDUConfigurationUpdateIEs_t));
2108       }
2109       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
2110             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2111       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
2112             (Size)sizeof(InitiatingMessage_t));
2113       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2114       RETVALUE(RFAILED);
2115    }
2116    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2117       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2118       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2119    DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2120          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2121          list.array[0]->sNSSAI.sD->buf,3*sizeof(uint8_t));
2122    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2123          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2124          list.array[0]->sNSSAI.sD->buf == NULLP)
2125    {
2126       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2127             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2128             list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2129       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2130             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2131             list.array[0]->sNSSAI.sST.buf,sizeof(uint8_t));
2132       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2133             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2134             list.array[0],sizeof( SliceSupportItem_t));
2135       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2136             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2137             list.array,sizeof( SliceSupportItem_t *));
2138       for(idy=0;idy<extensionCnt;idy++)
2139       {
2140          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2141                array[0]->iE_Extensions->list.array[idy],\
2142                sizeof(struct ServedPLMNs_ItemExtIEs));
2143       }
2144       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2145             array[0]->iE_Extensions->list.array,extensionCnt*\
2146             sizeof(struct ServedPLMNs_ItemExtIEs *));
2147       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2148             array[0]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
2149       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2150             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
2151       for(idy=0;idy<servPlmnCnt;idy++)
2152       {
2153          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
2154                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
2155       }
2156       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2157             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
2158       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2159             5*sizeof(uint8_t));
2160       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2161             3*sizeof(U8));
2162       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2163             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
2164       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
2165       DU_FREE(cellsToModify->list.array[idy],\
2166             sizeof(struct Served_Cells_To_Modify_ItemIEs));
2167       DU_FREE(cellsToModify->list.array,modifyCnt*\
2168             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
2169       for(idy=0;idy<elementCnt;idy++)
2170       {
2171          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
2172                sizeof(GNBDUConfigurationUpdateIEs_t));
2173       }
2174       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
2175             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2176       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
2177             (Size)sizeof(InitiatingMessage_t));
2178       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2179       RETVALUE(RFAILED);
2180    }
2181    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2182       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2183       list.array[0]->sNSSAI.sD->buf[0] = 3;
2184    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2185       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2186       list.array[0]->sNSSAI.sD->buf[1] = 6;
2187    modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2188       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2189       list.array[0]->sNSSAI.sD->buf[2] = 9;
2190
2191    /*nR Mode Info with FDD*/
2192    modifyItem->served_Cell_Information.nR_Mode_Info.present = \
2193                                                          NR_Mode_Info_PR_fDD;
2194    DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
2195          sizeof(FDD_Info_t));
2196    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD == NULLP)
2197    {
2198       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2199             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2200             list.array[0]->sNSSAI.sD->buf,3*sizeof(uint8_t));
2201       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2202             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2203             list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2204       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2205             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2206             list.array[0]->sNSSAI.sST.buf,sizeof(uint8_t));
2207       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2208             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2209             list.array[0],sizeof( SliceSupportItem_t));
2210       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2211             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2212             list.array,sizeof( SliceSupportItem_t *));
2213       for(idy=0;idy<extensionCnt;idy++)
2214       {
2215          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2216                array[0]->iE_Extensions->list.array[idy],\
2217                sizeof(struct ServedPLMNs_ItemExtIEs));
2218       }
2219       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2220             array[0]->iE_Extensions->list.array,extensionCnt*\
2221             sizeof(struct ServedPLMNs_ItemExtIEs *));
2222       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2223             array[0]->iE_Extensions,sizeof(struct ProtocolExtensionContainer_4624P3));
2224       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2225             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
2226       for(idy=0;idy<servPlmnCnt;idy++)
2227       {
2228          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
2229                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
2230       }
2231       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2232             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
2233       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2234             5*sizeof(uint8_t));
2235       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2236             3*sizeof(U8));
2237       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2238             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
2239       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
2240       DU_FREE(cellsToModify->list.array[idy],\
2241             sizeof(struct Served_Cells_To_Modify_ItemIEs));
2242       DU_FREE(cellsToModify->list.array,modifyCnt*\
2243             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
2244       for(idy=0;idy<elementCnt;idy++)
2245       {
2246          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
2247                sizeof(GNBDUConfigurationUpdateIEs_t));
2248       }
2249       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
2250             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2251       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
2252             (Size)sizeof(InitiatingMessage_t));
2253       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2254       RETVALUE(RFAILED);
2255    }
2256    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2257       uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2258       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2259    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2260       uL_NRFreqInfo.freqBandListNr.list.count = 1;
2261    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2262       uL_NRFreqInfo.freqBandListNr.list.size = \
2263       sizeof(struct FreqBandNrItem *);
2264    DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
2265          fDD->uL_NRFreqInfo.freqBandListNr.list.\
2266          array,sizeof(struct FreqBandNrItem *));
2267    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
2268          fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2269    {
2270       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
2271             sizeof(FDD_Info_t));
2272       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2273             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2274             list.array[0]->sNSSAI.sD->buf,3*sizeof(uint8_t));
2275       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2276             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2277             list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2278       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2279             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2280             list.array[0]->sNSSAI.sST.buf,sizeof(uint8_t));
2281       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2282             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2283             list.array[0],sizeof( SliceSupportItem_t));
2284       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2285             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2286             list.array,sizeof( SliceSupportItem_t *));
2287       for(idy=0;idy<extensionCnt;idy++)
2288       {
2289          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2290                array[0]->iE_Extensions->list.array[idy],\
2291                sizeof(struct ServedPLMNs_ItemExtIEs));
2292       }
2293       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2294             array[0]->iE_Extensions->list.array,extensionCnt*\
2295             sizeof(struct ServedPLMNs_ItemExtIEs *));
2296       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2297             array[0]->iE_Extensions,\
2298             sizeof(struct ProtocolExtensionContainer_4624P3));
2299       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2300             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
2301       for(idy=0;idy<servPlmnCnt;idy++)
2302       {
2303          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
2304                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
2305       }
2306       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2307             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
2308       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2309             5*sizeof(uint8_t));
2310       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2311             3*sizeof(U8));
2312       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2313             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
2314       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
2315       DU_FREE(cellsToModify->list.array[idy],\
2316             sizeof(struct Served_Cells_To_Modify_ItemIEs));
2317       DU_FREE(cellsToModify->list.array,modifyCnt*\
2318             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
2319       for(idy=0;idy<elementCnt;idy++)
2320       {
2321          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
2322                sizeof(GNBDUConfigurationUpdateIEs_t));
2323       }
2324       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
2325             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2326       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
2327             (Size)sizeof(InitiatingMessage_t));
2328       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2329       RETVALUE(RFAILED);
2330    }
2331    DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2332          uL_NRFreqInfo.freqBandListNr.list.\
2333          array[0],sizeof(struct FreqBandNrItem));
2334    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2335          uL_NRFreqInfo.freqBandListNr.list.\
2336          array[0] == NULLP)
2337    {
2338       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
2339             fDD->uL_NRFreqInfo.freqBandListNr.list.\
2340             array,sizeof(struct FreqBandNrItem *));
2341       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
2342             sizeof(FDD_Info_t));
2343       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2344             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2345             list.array[0]->sNSSAI.sD->buf,3*sizeof(uint8_t));
2346       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2347             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2348             list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2349       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2350             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2351             list.array[0]->sNSSAI.sST.buf,sizeof(uint8_t));
2352       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2353             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2354             list.array[0],sizeof( SliceSupportItem_t));
2355       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2356             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2357             list.array,sizeof( SliceSupportItem_t *));
2358       for(idy=0;idy<extensionCnt;idy++)
2359       {
2360          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2361                array[0]->iE_Extensions->list.array[idy],\
2362                sizeof(struct ServedPLMNs_ItemExtIEs));
2363       }
2364       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2365             array[0]->iE_Extensions->list.array,extensionCnt*\
2366             sizeof(struct ServedPLMNs_ItemExtIEs *));
2367       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2368             array[0]->iE_Extensions,\
2369             sizeof(struct ProtocolExtensionContainer_4624P3));
2370       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2371             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
2372       for(idy=0;idy<servPlmnCnt;idy++)
2373       {
2374          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
2375                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
2376       }
2377       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2378             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
2379       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2380             5*sizeof(uint8_t));
2381       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2382             3*sizeof(U8));
2383       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2384             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
2385       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
2386       DU_FREE(cellsToModify->list.array[idy],\
2387             sizeof(struct Served_Cells_To_Modify_ItemIEs));
2388       DU_FREE(cellsToModify->list.array,modifyCnt*\
2389             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
2390       for(idy=0;idy<elementCnt;idy++)
2391       {
2392          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
2393                sizeof(GNBDUConfigurationUpdateIEs_t));
2394       }
2395       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
2396             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2397       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
2398             (Size)sizeof(InitiatingMessage_t));
2399       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2400       RETVALUE(RFAILED);
2401    }
2402    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
2403       freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2404       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2405       freqBand[0].nrFreqBand;
2406    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
2407       freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2408    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
2409       nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2410       dlNrFreqInfo.nrArfcn;
2411    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
2412       freqBandListNr.list.count = 1;
2413    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
2414       freqBandListNr.list.size = sizeof(struct FreqBandNrItem *);
2415    DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2416          dL_NRFreqInfo.freqBandListNr.list.array,\
2417          sizeof(struct FreqBandNrItem *));
2418    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2419          dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2420    {
2421       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2422             uL_NRFreqInfo.freqBandListNr.list.\
2423             array[0],sizeof(struct FreqBandNrItem));
2424       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
2425             fDD->uL_NRFreqInfo.freqBandListNr.list.\
2426             array,sizeof(struct FreqBandNrItem *));
2427       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
2428             sizeof(FDD_Info_t));
2429       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2430             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2431             list.array[0]->sNSSAI.sD->buf,3*sizeof(uint8_t));
2432       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2433             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2434             list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2435       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2436             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2437             list.array[0]->sNSSAI.sST.buf,sizeof(uint8_t));
2438       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2439             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2440             list.array[0],sizeof( SliceSupportItem_t));
2441       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2442             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2443             list.array,sizeof( SliceSupportItem_t *));
2444       for(idy=0;idy<extensionCnt;idy++)
2445       {
2446          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2447                array[0]->iE_Extensions->list.array[idy],\
2448                sizeof(struct ServedPLMNs_ItemExtIEs));
2449       }
2450       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2451             array[0]->iE_Extensions->list.array,extensionCnt*\
2452             sizeof(struct ServedPLMNs_ItemExtIEs *));
2453       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2454             array[0]->iE_Extensions,\
2455             sizeof(struct ProtocolExtensionContainer_4624P3));
2456       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2457             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
2458       for(idy=0;idy<servPlmnCnt;idy++)
2459       {
2460          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
2461                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
2462       }
2463       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2464             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
2465       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2466             5*sizeof(uint8_t));
2467       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2468             3*sizeof(U8));
2469       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2470             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
2471       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
2472       DU_FREE(cellsToModify->list.array[idy],\
2473             sizeof(struct Served_Cells_To_Modify_ItemIEs));
2474       DU_FREE(cellsToModify->list.array,modifyCnt*\
2475             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
2476       for(idy=0;idy<elementCnt;idy++)
2477       {
2478          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
2479                sizeof(GNBDUConfigurationUpdateIEs_t));
2480       }
2481       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
2482             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2483       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
2484             (Size)sizeof(InitiatingMessage_t));
2485       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2486       RETVALUE(RFAILED);
2487    }
2488    DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2489          dL_NRFreqInfo.freqBandListNr.list.array[0],\
2490          sizeof(struct FreqBandNrItem));
2491    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2492          dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2493    {
2494       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2495             dL_NRFreqInfo.freqBandListNr.list.array,\
2496             sizeof(struct FreqBandNrItem *));
2497       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2498             uL_NRFreqInfo.freqBandListNr.list.\
2499             array[0],sizeof(struct FreqBandNrItem));
2500       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
2501             fDD->uL_NRFreqInfo.freqBandListNr.list.\
2502             array,sizeof(struct FreqBandNrItem *));
2503       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
2504             sizeof(FDD_Info_t));
2505       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2506             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2507             list.array[0]->sNSSAI.sD->buf,3*sizeof(uint8_t));
2508       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2509             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2510             list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2511       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2512             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2513             list.array[0]->sNSSAI.sST.buf,sizeof(uint8_t));
2514       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2515             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2516             list.array[0],sizeof( SliceSupportItem_t));
2517       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2518             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2519             list.array,sizeof( SliceSupportItem_t *));
2520       for(idy=0;idy<extensionCnt;idy++)
2521       {
2522          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2523                array[0]->iE_Extensions->list.array[idy],\
2524                sizeof(struct ServedPLMNs_ItemExtIEs));
2525       }
2526       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2527             array[0]->iE_Extensions->list.array,extensionCnt*\
2528             sizeof(struct ServedPLMNs_ItemExtIEs *));
2529       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2530             array[0]->iE_Extensions,\
2531             sizeof(struct ProtocolExtensionContainer_4624P3));
2532       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2533             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
2534       for(idy=0;idy<servPlmnCnt;idy++)
2535       {
2536          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
2537                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
2538       }
2539       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2540             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
2541       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2542             5*sizeof(uint8_t));
2543       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2544             3*sizeof(U8));
2545       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2546             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
2547       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
2548       DU_FREE(cellsToModify->list.array[idy],\
2549             sizeof(struct Served_Cells_To_Modify_ItemIEs));
2550       DU_FREE(cellsToModify->list.array,modifyCnt*\
2551             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
2552       for(idy=0;idy<elementCnt;idy++)
2553       {
2554          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
2555                sizeof(GNBDUConfigurationUpdateIEs_t));
2556       }
2557       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
2558             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2559       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
2560             (Size)sizeof(InitiatingMessage_t));
2561       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2562       RETVALUE(RFAILED);
2563    }
2564    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
2565       freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2566       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2567       freqBand[0].nrFreqBand;
2568    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
2569       freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2570
2571    /*Transmission Bandwidth*/
2572    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2573       uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2574       f1Mode.mode.fdd.ulTxBw.nrScs;
2575    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2576       uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2577       f1Mode.mode.fdd.ulTxBw.nrb;
2578
2579    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2580       dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2581       f1Mode.mode.fdd.dlTxBw.nrScs;
2582    modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2583       dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2584       f1Mode.mode.fdd.dlTxBw.nrb;
2585
2586    /*Measurement timing Config*/
2587    modifyItem->served_Cell_Information.measurementTimingConfiguration.size = \
2588                                                               sizeof(uint8_t);
2589    DU_ALLOC(modifyItem->served_Cell_Information.measurementTimingConfiguration.\
2590          buf,sizeof(uint8_t));
2591    if(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf == NULLP)
2592    {
2593       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2594             dL_NRFreqInfo.freqBandListNr.list.array[0],\
2595             sizeof(struct FreqBandNrItem));
2596       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2597             dL_NRFreqInfo.freqBandListNr.list.array,\
2598             sizeof(struct FreqBandNrItem *));
2599       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2600             uL_NRFreqInfo.freqBandListNr.list.\
2601             array[0],sizeof(struct FreqBandNrItem));
2602       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
2603             fDD->uL_NRFreqInfo.freqBandListNr.list.\
2604             array,sizeof(struct FreqBandNrItem *));
2605       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
2606             sizeof(FDD_Info_t));
2607       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2608             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2609             list.array[0]->sNSSAI.sD->buf,3*sizeof(uint8_t));
2610       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2611             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2612             list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2613       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2614             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2615             list.array[0]->sNSSAI.sST.buf,sizeof(uint8_t));
2616       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2617             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2618             list.array[0],sizeof( SliceSupportItem_t));
2619       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2620             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2621             list.array,sizeof( SliceSupportItem_t *));
2622       for(idy=0;idy<extensionCnt;idy++)
2623       {
2624          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2625                array[0]->iE_Extensions->list.array[idy],\
2626                sizeof(struct ServedPLMNs_ItemExtIEs));
2627       }
2628       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2629             array[0]->iE_Extensions->list.array,extensionCnt*\
2630             sizeof(struct ServedPLMNs_ItemExtIEs *));
2631       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2632             array[0]->iE_Extensions,\
2633             sizeof(struct ProtocolExtensionContainer_4624P3));
2634       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2635             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
2636       for(idy=0;idy<servPlmnCnt;idy++)
2637       {
2638          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
2639                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
2640       }
2641       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2642             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
2643       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2644             5*sizeof(uint8_t));
2645       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2646             3*sizeof(U8));
2647       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2648             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
2649       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
2650       DU_FREE(cellsToModify->list.array[idy],\
2651             sizeof(struct Served_Cells_To_Modify_ItemIEs));
2652       DU_FREE(cellsToModify->list.array,modifyCnt*\
2653             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
2654       for(idy=0;idy<elementCnt;idy++)
2655       {
2656          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
2657                sizeof(GNBDUConfigurationUpdateIEs_t));
2658       }
2659       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
2660             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2661       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
2662             (Size)sizeof(InitiatingMessage_t));
2663       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2664       RETVALUE(RFAILED);
2665    }
2666    modifyItem->served_Cell_Information.measurementTimingConfiguration.\
2667       buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2668
2669
2670    // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2671    /*GNB DU ID */
2672    duCfgUpdate->protocolIEs.list.array[2]->id = ProtocolIE_ID_id_gNB_DU_ID;
2673    duCfgUpdate->protocolIEs.list.array[2]->criticality = Criticality_reject;
2674    duCfgUpdate->protocolIEs.list.array[2]->value.present = \
2675                              GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2676    duCfgUpdate->protocolIEs.list.array[2]->value.choice.GNB_DU_ID.size = \
2677                                                              sizeof(uint8_t);
2678    DU_ALLOC(duCfgUpdate->protocolIEs.list.array[2]->value.choice.GNB_DU_ID.buf,\
2679          sizeof(uint8_t));
2680    if(duCfgUpdate->protocolIEs.list.array[2]->value.choice.GNB_DU_ID.buf == NULLP)
2681    {
2682       DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.\
2683             buf,sizeof(uint8_t));
2684       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2685             dL_NRFreqInfo.freqBandListNr.list.array[0],\
2686             sizeof(struct FreqBandNrItem));
2687       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2688             dL_NRFreqInfo.freqBandListNr.list.array,\
2689             sizeof(struct FreqBandNrItem *));
2690       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
2691             uL_NRFreqInfo.freqBandListNr.list.\
2692             array[0],sizeof(struct FreqBandNrItem));
2693       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
2694             fDD->uL_NRFreqInfo.freqBandListNr.list.\
2695             array,sizeof(struct FreqBandNrItem *));
2696       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
2697             sizeof(FDD_Info_t));
2698       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2699             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2700             list.array[0]->sNSSAI.sD->buf,3*sizeof(uint8_t));
2701       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2702             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2703             list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2704       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2705             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2706             list.array[0]->sNSSAI.sST.buf,sizeof(uint8_t));
2707       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2708             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2709             list.array[0],sizeof( SliceSupportItem_t));
2710       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
2711             iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2712             list.array,sizeof( SliceSupportItem_t *));
2713       for(idy=0;idy<extensionCnt;idy++)
2714       {
2715          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2716                array[0]->iE_Extensions->list.array[idy],\
2717                sizeof(struct ServedPLMNs_ItemExtIEs));
2718       }
2719       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2720             array[0]->iE_Extensions->list.array,extensionCnt*\
2721             sizeof(struct ServedPLMNs_ItemExtIEs *));
2722       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2723             array[0]->iE_Extensions,\
2724             sizeof(struct ProtocolExtensionContainer_4624P3));
2725       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
2726             array[0]->pLMN_Identity.buf,3*sizeof(uint8_t));
2727       for(idy=0;idy<servPlmnCnt;idy++)
2728       {
2729          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy],\
2730                servPlmnCnt*sizeof(struct ServedPLMNs_Item));
2731       }
2732       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2733             servPlmnCnt*sizeof(struct ServedPLMNs_Item *));
2734       DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2735             5*sizeof(uint8_t));
2736       DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2737             3*sizeof(U8));
2738       DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2739             modifyItem->oldNRCGI.nRCellIdentity.size*sizeof(uint8_t));
2740       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,3*sizeof(uint8_t));
2741       DU_FREE(cellsToModify->list.array[idy],\
2742             sizeof(struct Served_Cells_To_Modify_ItemIEs));
2743       DU_FREE(cellsToModify->list.array,modifyCnt*\
2744             sizeof(struct Served_Cells_To_Modify_ItemIEs *));
2745       for(idy=0;idy<elementCnt;idy++)
2746       {
2747          DU_FREE(duCfgUpdate->protocolIEs.list.array[idy], \
2748                sizeof(GNBDUConfigurationUpdateIEs_t));
2749       }
2750       DU_FREE(duCfgUpdate->protocolIEs.list.array,\
2751             elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2752       DU_FREE(f1apDuCfg->choice.initiatingMessage,\
2753             (Size)sizeof(InitiatingMessage_t));
2754       DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2755       RETVALUE(RFAILED);
2756    }
2757    duCfgUpdate->protocolIEs.list.array[2]->value.choice.GNB_DU_ID.buf[0] = \
2758                                                               duCfgParam.duId;
2759
2760
2761
2762 #endif
2763    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2764
2765    /* Encode the DU Config Update type as APER */
2766    cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
2767    encBufSize = 0;
2768    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2769
2770    /* Clean up */
2771    for(idx=0;idx<elementCnt;idx++)
2772    {
2773       DU_FREE(duCfgUpdate->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateIEs_t));
2774    }
2775    DU_FREE(duCfgUpdate->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t *));
2776    DU_FREE(f1apDuCfg->choice.initiatingMessage, (Size)sizeof(InitiatingMessage_t));
2777    DU_FREE(f1apDuCfg, sizeof(F1AP_PDU_t));
2778
2779    /* Checking encode results */
2780    if(encRetVal.encoded == ENCODE_FAIL)
2781    {
2782       DU_LOG("F1AP : Could not encode DUConfigUpdate structure (at %s)\n",encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2783       RETVALUE(RFAILED);
2784    }
2785    else
2786    {
2787       DU_LOG("\nF1AP : Created APER encoded buffer for DUConfigUpdate\n");
2788       for(int i=0; i< encBufSize; i++)
2789       {
2790          printf("%x",encBuf[i]);
2791       }
2792    }
2793
2794    /* Sending msg */
2795    if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
2796    {
2797       DU_LOG("\nF1AP : Sending GND-DU Config Update failed");
2798       RETVALUE(RFAILED);
2799    }
2800    return ROK;
2801 }/* End of BuildAndSendDUConfigUpdate */
2802
2803 /*******************************************************************
2804  *
2805  * @brief Builds and sends the ULRRCMessageTransfer
2806  *
2807  * @details
2808  *
2809  *    Function : BuildAndSendULRRCMessageTransfer
2810  *
2811  *    Functionality: Constructs the UL RRC Message Transfer and sends
2812  *                   it to the CU through SCTP.
2813  *
2814  * @params[in]
2815  *
2816  * @return ROK     - success
2817  *         RFAILED - failure
2818  *
2819  * ****************************************************************/
2820 S16 BuildAndSendULRRCMessageTransfer()
2821 {
2822         U8   elementCnt;
2823         U8   ieId;
2824         U8   idx;
2825         F1AP_PDU_t                              *f1apMsg = NULL;
2826    ULRRCMessageTransfer_t       *ulRRCMsg;
2827         asn_enc_rval_t                          encRetVal;        /* Encoder return value */
2828
2829         DU_LOG("\n F1AP : Building UL RRC Message Transfer Message\n");
2830
2831         DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2832         if(f1apMsg == NULLP)
2833         {
2834                 DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
2835                 RETVALUE(RFAILED);
2836         }
2837
2838         f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2839         DU_ALLOC(f1apMsg->choice.initiatingMessage,
2840                         sizeof(InitiatingMessage_t));
2841         if(f1apMsg->choice.initiatingMessage == NULLP)
2842         {
2843                 DU_LOG(" F1AP : Memory allocation for   F1AP-PDU failed");
2844                 DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2845                 RETVALUE(RFAILED);
2846         }
2847
2848         f1apMsg->choice.initiatingMessage->procedureCode = \
2849                                                                                                 ProcedureCode_id_ULRRCMessageTransfer;
2850         f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2851         f1apMsg->choice.initiatingMessage->value.present = \
2852                                                                 InitiatingMessage__value_PR_ULRRCMessageTransfer;
2853         ulRRCMsg =
2854                 &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2855         elementCnt = 3;
2856         ulRRCMsg->protocolIEs.list.count = elementCnt;
2857         ulRRCMsg->protocolIEs.list.size = \
2858                                                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2859
2860         /* Initialize the F1Setup members */
2861         DU_ALLOC(ulRRCMsg->protocolIEs.list.array, \
2862                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *));
2863         if(ulRRCMsg->protocolIEs.list.array == NULLP)
2864         {
2865                 DU_LOG(" F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2866                 DU_FREE(f1apMsg->choice.initiatingMessage,
2867                                 sizeof(InitiatingMessage_t));
2868                 DU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
2869                 RETVALUE(RFAILED);
2870         }
2871
2872         for(idx=0; idx<elementCnt; idx++)
2873         {
2874                 DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],\
2875                                                                                 sizeof(ULRRCMessageTransferIEs_t));
2876                 if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2877                 {
2878                         for(ieId=0; ieId<idx; ieId++)
2879                         {
2880                                 DU_FREE(ulRRCMsg->protocolIEs.list.array[ieId],\
2881                                                 sizeof(ULRRCMessageTransferIEs_t));
2882                         }
2883                         DU_FREE(ulRRCMsg->protocolIEs.list.array,\
2884                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *));
2885                         DU_FREE(f1apMsg->choice.initiatingMessage,\
2886                                                                                                 sizeof(InitiatingMessage_t));
2887                         DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2888                         RETVALUE(RFAILED);
2889                 }
2890         }
2891
2892         idx = 0;
2893
2894         /*GNB CU UE F1AP ID*/
2895         ulRRCMsg->protocolIEs.list.array[idx]->id       = \
2896                                                                                  ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2897         ulRRCMsg->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
2898         ulRRCMsg->protocolIEs.list.array[idx]->value.present = \
2899                                 ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2900         ulRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
2901
2902         /*GNB DU UE F1AP ID*/
2903         idx++;
2904         ulRRCMsg->protocolIEs.list.array[idx]->id       = \
2905                                                                                  ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2906         ulRRCMsg->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
2907         ulRRCMsg->protocolIEs.list.array[idx]->value.present = \
2908                                 ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2909         ulRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
2910
2911         /*SRBID*/
2912         idx++;
2913         ulRRCMsg->protocolIEs.list.array[idx]->id       = \
2914                                                                                                                  ProtocolIE_ID_id_SRBID;
2915         ulRRCMsg->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
2916         ulRRCMsg->protocolIEs.list.array[idx]->value.present = \
2917                                                                 ULRRCMessageTransferIEs__value_PR_SRBID;
2918         ulRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = UL_SRBID;
2919
2920         /*RRCContainer*/
2921         //YET TO FILL
2922
2923         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2924
2925         /* Encode the F1SetupRequest type as APER */
2926         cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
2927         encBufSize = 0;
2928         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2929                         encBuf);
2930         /* Encode results */
2931         if(encRetVal.encoded == ENCODE_FAIL)
2932         {
2933                 DU_LOG( "\n F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2934                                 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2935                 RETVALUE(RFAILED);
2936         }
2937         else
2938         {
2939                 DU_LOG("\n F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2940                 for(int i=0; i< encBufSize; i++)
2941                 {
2942                         printf("%x",encBuf[i]);
2943                 }
2944         }
2945
2946         /* Sending  msg  */
2947         if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL)       !=      ROK)
2948         {
2949                 DU_LOG("\n F1AP : Sending       UL RRC Message Transfer Failed");
2950                 RETVALUE(RFAILED);
2951         }
2952    return ROK;
2953 }/* End of BuildAndSendULRRCMessageTransfer*/
2954
2955 /*******************************************************************
2956  *
2957  * @brief Builds and sends the InitialULRRCMessage
2958  *
2959  * @details
2960  *
2961  *    Function : BuildAndSendRRCSetupReq
2962  *
2963  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
2964  *                   it to the CU through SCTP.
2965  *
2966  * @params[in]
2967  *
2968  * @return ROK     - success
2969  *         RFAILED - failure
2970  *
2971  * ****************************************************************/
2972 S16 BuildAndSendRRCSetupReq()
2973 {
2974         S16  ret;
2975         U8   elementCnt;
2976         U8   ieId;
2977         U8   idx;
2978         F1AP_PDU_t                                              *f1apMsg = NULL;
2979    InitialULRRCMessageTransfer_t        *initULRRCMsg;
2980         asn_enc_rval_t                                          encRetVal;        /* Encoder return value */
2981
2982         DU_LOG("\n F1AP : Building RRC Setup Request\n");
2983
2984         DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2985         if(f1apMsg == NULLP)
2986         {
2987                 DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
2988                 RETVALUE(RFAILED);
2989         }
2990
2991         f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2992         DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2993         if(f1apMsg->choice.initiatingMessage == NULLP)
2994         {
2995                 DU_LOG(" F1AP : Memory allocation for   F1AP-PDU failed");
2996                 DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2997                 RETVALUE(RFAILED);
2998         }
2999
3000         f1apMsg->choice.initiatingMessage->procedureCode = \
3001                                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
3002         f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
3003         f1apMsg->choice.initiatingMessage->value.present = \
3004                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
3005         initULRRCMsg =
3006                 &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
3007         elementCnt = 3;
3008         initULRRCMsg->protocolIEs.list.count = elementCnt;
3009         initULRRCMsg->protocolIEs.list.size = \
3010                                                                         elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
3011
3012         /* Initialize the F1Setup members */
3013         DU_ALLOC(initULRRCMsg->protocolIEs.list.array, \
3014                         elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *));
3015         if(initULRRCMsg->protocolIEs.list.array == NULLP)
3016         {
3017                 DU_LOG(" F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
3018                 DU_FREE(f1apMsg->choice.initiatingMessage,
3019                                 sizeof(InitiatingMessage_t));
3020                 DU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
3021                 RETVALUE(RFAILED);
3022         }
3023
3024         for(idx=0; idx<elementCnt; idx++)
3025         {
3026                 DU_ALLOC(initULRRCMsg->protocolIEs.list.array[idx],\
3027                                                                                 sizeof(InitialULRRCMessageTransferIEs_t));
3028                 if(initULRRCMsg->protocolIEs.list.array[idx] == NULLP)
3029                 {
3030                         for(ieId=0; ieId<idx; ieId++)
3031                         {
3032                                 DU_FREE(initULRRCMsg->protocolIEs.list.array[ieId],\
3033                                                 sizeof(InitialULRRCMessageTransferIEs_t));
3034                         }
3035                         DU_FREE(initULRRCMsg->protocolIEs.list.array,\
3036                                         elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *));
3037                         DU_FREE(f1apMsg->choice.initiatingMessage,\
3038                                                                                                 sizeof(InitiatingMessage_t));
3039                         DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
3040                         RETVALUE(RFAILED);
3041                 }
3042         }
3043
3044         idx = 0;
3045
3046         /*GNB DU UE F1AP ID*/
3047         initULRRCMsg->protocolIEs.list.array[idx]->id   = \
3048                                                                                  ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
3049         initULRRCMsg->protocolIEs.list.array[idx]->criticality  =       Criticality_reject;
3050         initULRRCMsg->protocolIEs.list.array[idx]->value.present = \
3051                                 InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
3052         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
3053
3054         /*NRCGI*/
3055         idx++;
3056         initULRRCMsg->protocolIEs.list.array[idx]->id   = \
3057                                                                                                                  ProtocolIE_ID_id_NRCGI;
3058         initULRRCMsg->protocolIEs.list.array[idx]->criticality  =       Criticality_reject;
3059         initULRRCMsg->protocolIEs.list.array[idx]->value.present = \
3060                                                                 InitialULRRCMessageTransferIEs__value_PR_NRCGI;
3061         ret = \
3062         BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI);
3063         if(ret != ROK)
3064         {
3065                 DU_FREE(initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.\
3066                                         nRCellIdentity.buf,initULRRCMsg->protocolIEs.list.array[idx]->\
3067                                         value.choice.NRCGI.nRCellIdentity.size);
3068                 DU_FREE(initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.\
3069                                         pLMN_Identity.buf,initULRRCMsg->protocolIEs.list.array[idx]->\
3070                                         value.choice.NRCGI.pLMN_Identity.size);
3071                 for(idx=0; idx<elementCnt; idx++)
3072                 {
3073                         DU_FREE(initULRRCMsg->protocolIEs.list.array[idx],\
3074                                         sizeof(InitialULRRCMessageTransferIEs_t));
3075                 }
3076                 DU_FREE(initULRRCMsg->protocolIEs.list.array,\
3077                                 elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *));
3078                 DU_FREE(f1apMsg->choice.initiatingMessage,\
3079                                 sizeof(InitiatingMessage_t));
3080                 DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
3081                 RETVALUE(RFAILED);
3082
3083         }
3084
3085         /*Cell RNTI*/
3086         idx++;
3087         initULRRCMsg->protocolIEs.list.array[idx]->id   = \
3088                                                                                                                  ProtocolIE_ID_id_C_RNTI;
3089         initULRRCMsg->protocolIEs.list.array[idx]->criticality  =       Criticality_reject;
3090         initULRRCMsg->protocolIEs.list.array[idx]->value.present = \
3091                                                 InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
3092         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI = CRNTI;
3093
3094         /*RRCContainer*/
3095         // Need to fill this.
3096
3097         /*DUtoCURRCContainer*/
3098         //Need to fill this too.
3099
3100
3101         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
3102
3103         /* Encode the F1SetupRequest type as APER */
3104         cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
3105         encBufSize = 0;
3106         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
3107                         encBuf);
3108         /* Encode results */
3109         if(encRetVal.encoded == ENCODE_FAIL)
3110         {
3111                 DU_LOG( "\n F1AP : Could not encode Initial UL RRC Message Transfer structure (at %s)\n",\
3112                                 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3113                 RETVALUE(RFAILED);
3114         }
3115         else
3116         {
3117                 DU_LOG("\n F1AP : Created APER encoded buffer for Initial UL RRC Message transfer\n");
3118                 for(int i=0; i< encBufSize; i++)
3119                 {
3120                         printf("%x",encBuf[i]);
3121                 }
3122         }
3123
3124         /* Sending  msg  */
3125         if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL)       !=      ROK)
3126         {
3127                 DU_LOG("\n F1AP : Sending       Initial UL RRC Message Transfer Failed");
3128                 RETVALUE(RFAILED);
3129         }
3130    return ROK;
3131 }/* End of BuildAndSendRRCSetupReq*/
3132
3133 /*******************************************************************
3134  *
3135  * @brief Builds Special cell list for UE Setup Request
3136  *
3137  * @details
3138  *
3139  *    Function : BuildSplCellList
3140  *
3141  *    Functionality: Constructs the Special Cell list for UESetReq
3142  *
3143  * @params[in] SCell_ToBeSetup_List_t *spCellLst
3144  *
3145  * @return ROK     - success
3146  *         RFAILED - failure
3147  *
3148  * ****************************************************************/
3149 S16 BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
3150 {
3151         U8  cellCnt;
3152         U8  idx;
3153         U8  cellidx;
3154         S16 ret;
3155         cellCnt = 1;
3156         spCellLst->list.count = cellCnt;
3157         spCellLst->list.size = cellCnt * sizeof(struct SCell_ToBeSetup_ItemIEs *);
3158         DU_ALLOC(spCellLst->list.array,spCellLst->list.size);
3159         if(spCellLst->list.array == NULLP)
3160         {
3161                 RETVALUE(RFAILED);
3162         }
3163         for(idx=0; idx<cellCnt; idx++)
3164         {
3165                 DU_ALLOC(spCellLst->list.array[idx],sizeof(struct SCell_ToBeSetup_ItemIEs));
3166                 if(spCellLst->list.array[idx] == NULLP)
3167                 {
3168                         for(cellidx=0; cellidx<idx; cellidx++)
3169                         {
3170                                 DU_FREE(spCellLst->list.array[cellidx],sizeof(struct SCell_ToBeSetup_ItemIEs));
3171                         }
3172                         DU_FREE(spCellLst->list.array,spCellLst->list.size);
3173                         RETVALUE(RFAILED);
3174                 }
3175         }
3176         idx = 0;
3177         spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
3178         spCellLst->list.array[idx]->criticality = Criticality_ignore;
3179         spCellLst->list.array[idx]->value.present =\
3180                 SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
3181         /* Special Cell ID -NRCGI */
3182         ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
3183         if(ret != ROK)
3184         {
3185                 for(cellidx=0; cellidx<cellCnt; cellidx++)
3186                 {
3187                         DU_FREE(spCellLst->list.array[cellidx],sizeof(struct
3188                         SCell_ToBeSetup_ItemIEs));
3189                 }
3190                 DU_FREE(spCellLst->list.array,spCellLst->list.size);
3191                 RETVALUE(RFAILED);
3192         }
3193         /*Special Cell Index*/
3194         spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
3195   return ROK;
3196 }/* End of BuildSplCellList*/
3197
3198 /*******************************************************************
3199  *
3200  * @brief Builds SRBS to be setup
3201  *
3202  * @details
3203  *
3204  *    Function : BuildSRBSetup
3205  *
3206  *    Functionality: Constructs the SRB's for UESetReq
3207  *
3208  * @params[in] SRBs_ToBeSetup_List_t *srbSet
3209  *
3210  * @return ROK     - success
3211  *         RFAILED - failure
3212  *
3213  * ****************************************************************/
3214 S16 BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
3215 {
3216         U8 idx;
3217         U8 srbidx;
3218         U8 srbCnt;
3219         srbCnt = 1;
3220         srbSet->list.count = srbCnt;
3221         srbSet->list.size = srbCnt*sizeof(struct SRBs_ToBeSetup_ItemIEs *);
3222         DU_ALLOC(srbSet->list.array,srbSet->list.size);
3223         if(srbSet->list.array == NULLP)
3224         {
3225                 RETVALUE(RFAILED);
3226         }
3227         for(idx=0; idx<srbCnt; idx++)
3228         {
3229                 DU_ALLOC(srbSet->list.array[idx],sizeof(struct SRBs_ToBeSetup_ItemIEs));
3230                 if(srbSet->list.array[idx] == NULLP)
3231                 {
3232                         for(srbidx=0; srbidx<idx; srbidx++)
3233                         {
3234                                 DU_FREE(srbSet->list.array[srbidx],sizeof(struct SRBs_ToBeSetup_ItemIEs));
3235                         }
3236                         DU_FREE(srbSet->list.array,srbSet->list.size);
3237                 }
3238         }
3239         idx = 0;
3240         srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
3241         srbSet->list.array[idx]->criticality = Criticality_ignore;
3242         srbSet->list.array[idx]->value.present = \
3243                         SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
3244    srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
3245    return ROK;
3246 }/* End of BuildSRBSetup*/
3247
3248 /*******************************************************************
3249  *
3250  * @brief Builds QOS Info for DRB Setum Item
3251  *
3252  * @details
3253  *
3254  *    Function : BuildQOSInfo
3255  *
3256  *    Functionality: Constructs the QOS Info for DRB Setup Item
3257  *
3258  * @params[in] QoSInformation_t *qosinfo
3259  *
3260  * @return ROK     - success
3261  *         RFAILED - failure
3262  *
3263  * ****************************************************************/
3264 S16 BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
3265 {
3266         /* NonDynamic5QIDescriptor */
3267         drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
3268         DU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3269         if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
3270         {
3271                 RETVALUE(RFAILED);
3272         }
3273         /*FiveQI*/
3274         drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = 0;
3275         /*AveragingWindow*/
3276         DU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
3277                                                                                                 sizeof(AveragingWindow_t));
3278         if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
3279                                                                                                                                                                                                         NULLP)
3280         {
3281                 DU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
3282                                                 sizeof(NonDynamic5QIDescriptor_t));
3283                 RETVALUE(RFAILED);
3284         }
3285         *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
3286         /*MaxDataBurstVolume*/
3287         DU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3288                                                                                                 sizeof(MaxDataBurstVolume_t));
3289         if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
3290                                                                                                                                                                                                         NULLP)
3291         {
3292                 DU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
3293                                                                                                 sizeof(AveragingWindow_t));
3294                 DU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
3295                                                 sizeof(NonDynamic5QIDescriptor_t));
3296                 RETVALUE(RFAILED);
3297         }
3298         *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
3299
3300         /*nRGRAN Allocation Retention Priority*/
3301         drbQos->nGRANallocationRetentionPriority.priorityLevel =        \
3302                                                                                                 PriorityLevel_highest;
3303         drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = \
3304                                                         Pre_emptionCapability_may_trigger_pre_emption;
3305         drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = \
3306                                                                 Pre_emptionVulnerability_not_pre_emptable;
3307
3308         /* TO DO: GBR_QoSFlowInformation */
3309         return ROK;
3310 }/*End of BuildQOSInfo*/
3311
3312 /*******************************************************************
3313  *
3314  * @brief Builds SNSSAI
3315  *
3316  * @details
3317  *
3318  *    Function : BuildSNSSAI
3319  *
3320  *    Functionality: Constructs the SNSSAI For DRB list
3321  *
3322  * @params[in] SNSSAI_t *snssai
3323  *
3324  * @return ROK     - success
3325  *         RFAILED - failure
3326  *
3327  * ****************************************************************/
3328 S16 BuildSNSSAI(SNSSAI_t *snssai)
3329 {
3330         /*SNSSAI*/
3331           /*ssT*/
3332         snssai->sST.size = sizeof(U8);
3333         DU_ALLOC(snssai->sST.buf,snssai->sST.size);
3334         if(snssai->sST.buf == NULLP)
3335         {
3336                 RETVALUE(RFAILED);
3337         }
3338         snssai->sST.buf[0] = 3;
3339           /*sD*/
3340         DU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
3341         if(snssai->sD == NULLP)
3342         {
3343                 DU_FREE(snssai->sST.buf,snssai->sST.size);
3344                 RETVALUE(RFAILED);
3345         }
3346         snssai->sD->size = 3*sizeof(U8);
3347         DU_ALLOC(snssai->sD->buf,snssai->sD->size);
3348         if(snssai->sD->buf == NULLP)
3349         {
3350                 DU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
3351                 DU_FREE(snssai->sST.buf,snssai->sST.size);
3352                 RETVALUE(RFAILED);
3353         }
3354                 snssai->sD->buf[0] = 3;
3355                 snssai->sD->buf[1] = 6;
3356                 snssai->sD->buf[2] = 9;
3357    return ROK;
3358 }/*End of BuildSNSSAI*/
3359
3360 /*******************************************************************
3361  *
3362  * @brief Builds the flow map.
3363  *
3364  * @details
3365  *
3366  *    Function : BuildFlowsMap
3367  *
3368  *    Functionality: Constructs the flowmap For DRB list
3369  *
3370  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
3371  *
3372  * @return ROK     - success
3373  *         RFAILED - failure
3374  *
3375  * ****************************************************************/
3376 S16 BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap)
3377 {
3378         S16 ret;
3379         U8  idx;
3380         U8  flowidx;
3381         U8 flowCnt;
3382         flowCnt = 1;
3383         flowMap->list.count = flowCnt;
3384         flowMap->list.size = flowCnt * sizeof(struct Flows_Mapped_To_DRB_Item *);
3385         DU_ALLOC(flowMap->list.array,flowMap->list.size);
3386         if(flowMap->list.array == NULLP)
3387         {
3388                 RETVALUE(RFAILED);
3389         }
3390         for(idx=0; idx<flowCnt; idx++)
3391         {
3392                 DU_ALLOC(flowMap->list.array[idx],sizeof(struct Flows_Mapped_To_DRB_Item));
3393                 if(flowMap->list.array[idx] == NULLP)
3394                 {
3395                         for(flowidx=0; flowidx<idx; flowidx++)
3396                         {
3397                                 DU_FREE(flowMap->list.array[flowidx],sizeof(struct \
3398                                                         Flows_Mapped_To_DRB_Item));
3399                         }
3400
3401                         DU_FREE(flowMap->list.array,flowMap->list.size);
3402                 }
3403         }
3404         idx = 0;
3405         flowMap->list.array[idx]->qoSFlowIdentifier = 0;
3406         ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters);
3407         if(ret != ROK)
3408         {
3409                 DU_FREE(flowMap->list.array[idx]->qoSFlowLevelQoSParameters.\
3410                         qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3411                         sizeof(MaxDataBurstVolume_t));
3412                 DU_FREE(flowMap->list.array[idx]->qoSFlowLevelQoSParameters.\
3413                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
3414                         sizeof(AveragingWindow_t));
3415                 DU_FREE(flowMap->list.array[idx]->qoSFlowLevelQoSParameters.\
3416                         qoS_Characteristics.choice.non_Dynamic_5QI,\
3417                         sizeof(NonDynamic5QIDescriptor_t));
3418                 for(idx=0; idx<flowCnt; idx++)
3419                 {
3420                         DU_FREE(flowMap->list.array[idx],sizeof(struct Flows_Mapped_To_DRB_Item));
3421                 }
3422                 DU_FREE(flowMap->list.array,flowMap->list.size);
3423                 RETVALUE(RFAILED);
3424         }
3425    return ROK;
3426 }/*End of BuildFlowsMap*/
3427
3428 /*******************************************************************
3429  *
3430  * @brief Builds the Uplink Tunnel Info
3431  *
3432  * @details
3433  *
3434  *    Function : BuildULTnlInfo
3435  *
3436  *    Functionality: Constructs the UL TnlInfo For DRB list
3437  *
3438  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
3439  *
3440  * @return ROK     - success
3441  *         RFAILED - failure
3442  *
3443  * ****************************************************************/
3444 S16 BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
3445 {
3446         U8 idx;
3447         U8 ulidx;
3448         U8 ulCnt;
3449         ulCnt = 1;
3450         ulInfo->list.count = ulCnt;
3451         ulInfo->list.size = ulCnt * sizeof(struct \
3452                                 ULUPTNLInformation_ToBeSetup_Item *);
3453         DU_ALLOC(ulInfo->list.array,ulInfo->list.size);
3454         if(ulInfo->list.array == NULLP)
3455         {
3456                 RETVALUE(RFAILED);
3457         }
3458         for(idx=0; idx<ulCnt; idx++)
3459         {
3460                 DU_ALLOC(ulInfo->list.array[idx],sizeof(struct \
3461                                         ULUPTNLInformation_ToBeSetup_Item));
3462                 if(ulInfo->list.array[idx] == NULLP)
3463                 {
3464                         for(ulidx=0; ulidx<idx; ulidx++)
3465                         {
3466                                 DU_FREE(ulInfo->list.array[ulidx],sizeof(struct \
3467                                                         ULUPTNLInformation_ToBeSetup_Item));
3468                         }
3469                         DU_FREE(ulInfo->list.array,ulInfo->list.size);
3470                         RETVALUE(RFAILED);
3471                 }
3472         }
3473         idx = 0;
3474         ulInfo->list.array[idx]->uLUPTNLInformation.present = \
3475                                                                 UPTransportLayerInformation_PR_gTPTunnel;
3476         /*GTP TUNNEL*/
3477         DU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
3478                                 sizeof(struct GTPTunnel));
3479         if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
3480         {
3481                 for(idx=0; idx<ulCnt; idx++)
3482                 {
3483                         DU_FREE(ulInfo->list.array[idx],sizeof(struct \
3484                                                 ULUPTNLInformation_ToBeSetup_Item));
3485                 }
3486                 DU_FREE(ulInfo->list.array,ulInfo->list.size);
3487                 RETVALUE(RFAILED);
3488         }
3489         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3490                 transportLayerAddress.size      = 4*sizeof(U8);
3491    DU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3492                 transportLayerAddress.buf,ulInfo->list.array[idx]->\
3493                 uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3494         if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3495                 transportLayerAddress.buf == NULLP)
3496         {
3497                 DU_FREE(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
3498                                 sizeof(struct GTPTunnel));
3499                 for(idx=0; idx<ulCnt; idx++)
3500                 {
3501                         DU_FREE(ulInfo->list.array[idx],sizeof(struct \
3502                                                 ULUPTNLInformation_ToBeSetup_Item));
3503                 }
3504                 DU_FREE(ulInfo->list.array,ulInfo->list.size);
3505                 RETVALUE(RFAILED);
3506         }
3507         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3508                 transportLayerAddress.buf[0] = 4;
3509         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3510                 transportLayerAddress.buf[1] = 4;
3511         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3512                 transportLayerAddress.buf[2] = 4;
3513         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3514                 transportLayerAddress.buf[3] = 5;
3515         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3516                 transportLayerAddress.bits_unused = 0;
3517         /*GTP TEID*/
3518         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
3519                                         = 4 * sizeof(U8);
3520         DU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3521                                 gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
3522                                 gTPTunnel->gTP_TEID.size);
3523         if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3524                                 == NULLP)
3525         {
3526                 DU_FREE(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3527                                 transportLayerAddress.buf,ulInfo->list.array[idx]->\
3528                                 uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3529                 DU_FREE(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
3530                                 sizeof(struct GTPTunnel));
3531                 for(idx=0; idx<ulCnt; idx++)
3532                 {
3533                         DU_FREE(ulInfo->list.array[idx],sizeof(struct \
3534                                                 ULUPTNLInformation_ToBeSetup_Item));
3535                 }
3536                 DU_FREE(ulInfo->list.array,ulInfo->list.size);
3537                 RETVALUE(RFAILED);
3538         }
3539         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3540                 gTP_TEID.buf[0] = 11;
3541         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3542                 gTP_TEID.buf[1] = 0;
3543         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3544                 gTP_TEID.buf[2] = 0;
3545         ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
3546                 gTP_TEID.buf[3] = 1;
3547
3548    return ROK;
3549 }/*End of BuildULTnlInfo*/
3550
3551 /*******************************************************************
3552  *
3553  * @brief Builds DRBS to be setup
3554  *
3555  * @details
3556  *
3557  *    Function : BuildDRBSetup
3558  *
3559  *    Functionality: Constructs the DRB's for UESetReq
3560  *
3561  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3562  *
3563  * @return ROK     - success
3564  *         RFAILED - failure
3565  *
3566  * ****************************************************************/
3567 S16 BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3568 {
3569         S16 ret;
3570         U8       idx;
3571         U8  drbidx;
3572         U8  drbCnt;
3573         U8  flowidx;
3574         U8  flowCnt;
3575         U8  ulidx;
3576         U8  ulCnt;
3577         DRBs_ToBeSetup_Item_t *drbSetItem;
3578         drbCnt = 1;
3579         drbSet->list.count = drbCnt;
3580         drbSet->list.size = drbCnt*sizeof(struct DRBs_ToBeSetup_ItemIEs *);
3581         DU_ALLOC(drbSet->list.array,drbSet->list.size);
3582         if(drbSet->list.array == NULLP)
3583         {
3584                 RETVALUE(RFAILED);
3585         }
3586         for(idx=0; idx<drbCnt; idx++)
3587         {
3588                 DU_ALLOC(drbSet->list.array[idx],sizeof(struct DRBs_ToBeSetup_ItemIEs));
3589                 if(drbSet->list.array[idx] == NULLP)
3590                 {
3591                         for(drbidx=0; drbidx<idx; drbidx++)
3592                         {
3593                                 DU_FREE(drbSet->list.array[drbidx],sizeof(struct DRBs_ToBeSetup_ItemIEs));
3594                         }
3595                         DU_FREE(drbSet->list.array,drbSet->list.size);
3596                         RETVALUE(RFAILED);
3597                 }
3598         }
3599         idx = 0;
3600         drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
3601         drbSet->list.array[idx]->criticality = Criticality_ignore;
3602         drbSet->list.array[idx]->value.present = \
3603                         DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
3604    drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
3605         /*dRBID*/
3606         drbSetItem->dRBID = 1;
3607         /*qoSInformation*/
3608         drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
3609         DU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(struct\
3610                                         QoSInformation_ExtIEs));
3611         if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
3612         {
3613                 for(idx=0; idx<drbCnt; idx++)
3614                 {
3615                         DU_FREE(drbSet->list.array[idx],sizeof(struct DRBs_ToBeSetup_ItemIEs));
3616                 }
3617                 DU_FREE(drbSet->list.array,drbSet->list.size);
3618                 RETVALUE(RFAILED);
3619         }
3620         drbSetItem->qoSInformation.choice.choice_extension->id = \
3621                                                         ProtocolIE_ID_id_DRB_Information;
3622         drbSetItem->qoSInformation.choice.choice_extension->criticality = \
3623                                                         Criticality_ignore;
3624         drbSetItem->qoSInformation.choice.choice_extension->value.present = \
3625                                                         QoSInformation_ExtIEs__value_PR_DRB_Information;
3626         ret = BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
3627                                                         choice_extension->value.choice.DRB_Information.dRB_QoS);
3628         if(ret != ROK)
3629         {
3630                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(struct\
3631                                         QoSInformation_ExtIEs));
3632                 for(drbidx=0; drbidx<drbCnt; drbidx++)
3633                 {
3634                         DU_FREE(drbSet->list.array[drbidx],sizeof(struct DRBs_ToBeSetup_ItemIEs));
3635                 }
3636                 DU_FREE(drbSet->list.array,drbSet->list.size);
3637                 RETVALUE(RFAILED);
3638         }
3639         /*SNSSAI*/
3640         ret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
3641                                                         choice_extension->value.choice.DRB_Information.sNSSAI);
3642         if(ret != ROK)
3643         {
3644                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3645                                 choice.DRB_Information.dRB_QoS.qoS_Characteristics.choice.\
3646                                 non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3647                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3648                                 choice.DRB_Information.dRB_QoS.qoS_Characteristics.choice.\
3649                                 non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3650                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(struct\
3651                                         QoSInformation_ExtIEs));
3652                 for(drbidx=0; drbidx<drbCnt; drbidx++)
3653                 {
3654                         DU_FREE(drbSet->list.array[drbidx],sizeof(struct DRBs_ToBeSetup_ItemIEs));
3655                 }
3656                 DU_FREE(drbSet->list.array,drbSet->list.size);
3657                 RETVALUE(RFAILED);
3658         }
3659         /*Flows mapped to DRB List*/
3660         ret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
3661                                 choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List);
3662         if(ret != ROK)
3663         {
3664                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3665                                 choice.DRB_Information.sNSSAI.sD,sizeof(OCTET_STRING_t));
3666                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3667                                 choice.DRB_Information.sNSSAI.sD->buf,drbSetItem->qoSInformation.\
3668                                 choice.choice_extension->value.choice.DRB_Information.\
3669                                 sNSSAI.sD->size);
3670                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3671                                 choice.DRB_Information.sNSSAI.sST.buf,drbSetItem->qoSInformation.\
3672                                 choice.choice_extension->value.choice.DRB_Information.\
3673                                 sNSSAI.sST.size);
3674                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3675                                 choice.DRB_Information.dRB_QoS.qoS_Characteristics.choice.\
3676                                 non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3677                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3678                                 choice.DRB_Information.dRB_QoS.qoS_Characteristics.choice.\
3679                                 non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3680                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(struct\
3681                                         QoSInformation_ExtIEs));
3682                 for(drbidx=0; drbidx<drbCnt; drbidx++)
3683                 {
3684                         DU_FREE(drbSet->list.array[drbidx],sizeof(struct DRBs_ToBeSetup_ItemIEs));
3685                 }
3686                 DU_FREE(drbSet->list.array,drbSet->list.size);
3687                 RETVALUE(RFAILED);
3688         }
3689         /*ULUPTNLInformation To Be Setup List*/
3690    ret = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3691         if(ret != ROK)
3692         {
3693                 flowidx=0;
3694                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3695                                 choice.DRB_Information.flows_Mapped_To_DRB_List.list.\
3696                                 array[flowidx]->qoSFlowLevelQoSParameters.qoS_Characteristics.\
3697                                 choice.non_Dynamic_5QI->maxDataBurstVolume,\
3698                                 sizeof(MaxDataBurstVolume_t));
3699                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3700                                 choice.DRB_Information.flows_Mapped_To_DRB_List.list.\
3701                                 array[flowidx]->qoSFlowLevelQoSParameters.qoS_Characteristics.\
3702                                 choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3703                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3704                                 choice.DRB_Information.flows_Mapped_To_DRB_List.list.\
3705                                 array[flowidx]->qoSFlowLevelQoSParameters.qoS_Characteristics.\
3706                                 choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3707                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3708                                 choice.DRB_Information.flows_Mapped_To_DRB_List.list.\
3709                                 array,drbSetItem->qoSInformation.choice.choice_extension->\
3710                                 value.choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3711                                 flowCnt = 1;
3712                 for(flowidx=0; flowidx<flowCnt;flowidx++)
3713                 {
3714                         DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3715                                         choice.DRB_Information.flows_Mapped_To_DRB_List.list.\
3716                                         array[flowidx],sizeof(struct Flows_Mapped_To_DRB_Item));
3717                 }
3718                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3719                                 choice.DRB_Information.sNSSAI.sD,sizeof(OCTET_STRING_t));
3720                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3721                                 choice.DRB_Information.sNSSAI.sD->buf,drbSetItem->qoSInformation.\
3722                                 choice.choice_extension->value.choice.DRB_Information.\
3723                                 sNSSAI.sD->size);
3724                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3725                                 choice.DRB_Information.sNSSAI.sST.buf,drbSetItem->qoSInformation.\
3726                                 choice.choice_extension->value.choice.DRB_Information.\
3727                                 sNSSAI.sST.size);
3728                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3729                                 choice.DRB_Information.dRB_QoS.qoS_Characteristics.choice.\
3730                                 non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3731                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3732                                 choice.DRB_Information.dRB_QoS.qoS_Characteristics.choice.\
3733                                 non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3734                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(struct\
3735                                         QoSInformation_ExtIEs));
3736                 for(drbidx=0; drbidx<drbCnt; drbidx++)
3737                 {
3738                         DU_FREE(drbSet->list.array[drbidx],sizeof(struct DRBs_ToBeSetup_ItemIEs));
3739                 }
3740                 DU_FREE(drbSet->list.array,drbSet->list.size);
3741                 RETVALUE(RFAILED);
3742         }
3743         /*RLCMode*/
3744         drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
3745
3746         /*UL Configuration*/
3747         ulCnt = 1;
3748         DU_ALLOC(drbSetItem->uLConfiguration,sizeof(struct ULConfiguration));
3749         if(drbSetItem->uLConfiguration == NULLP)
3750         {
3751                 ulidx=0;
3752                 DU_FREE(drbSetItem->uLUPTNLInformation_ToBeSetup_List.list.array[ulidx]->\
3753                                 uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
3754                                 drbSetItem->uLUPTNLInformation_ToBeSetup_List.list.array[ulidx]->\
3755                                 uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
3756                 DU_FREE(drbSetItem->uLUPTNLInformation_ToBeSetup_List.list.array[ulidx]->\
3757                                 uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
3758                                 drbSetItem->uLUPTNLInformation_ToBeSetup_List.list.array[ulidx]->\
3759                                 uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3760                 DU_FREE(drbSetItem->uLUPTNLInformation_ToBeSetup_List.list.array[ulidx]->\
3761                                 uLUPTNLInformation.choice.gTPTunnel,sizeof(struct GTPTunnel));
3762                 DU_FREE(drbSetItem->uLUPTNLInformation_ToBeSetup_List.list.array,\
3763                                 drbSetItem->uLUPTNLInformation_ToBeSetup_List.list.size);
3764                 for(ulidx=0; ulidx<ulCnt; ulidx++)
3765                 {
3766                         DU_FREE(drbSetItem->uLUPTNLInformation_ToBeSetup_List.list.array[ulidx],\
3767                                         sizeof(struct ULUPTNLInformation_ToBeSetup_Item));
3768                 }
3769                 flowidx=0;
3770                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3771                                 choice.DRB_Information.flows_Mapped_To_DRB_List.list.\
3772                                 array[flowidx]->qoSFlowLevelQoSParameters.qoS_Characteristics.\
3773                                 choice.non_Dynamic_5QI->maxDataBurstVolume,\
3774                                 sizeof(MaxDataBurstVolume_t));
3775                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3776                                 choice.DRB_Information.flows_Mapped_To_DRB_List.list.\
3777                                 array[flowidx]->qoSFlowLevelQoSParameters.qoS_Characteristics.\
3778                                 choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3779                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3780                                 choice.DRB_Information.flows_Mapped_To_DRB_List.list.\
3781                                 array[flowidx]->qoSFlowLevelQoSParameters.qoS_Characteristics.\
3782                                 choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3783                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3784                                 choice.DRB_Information.flows_Mapped_To_DRB_List.list.\
3785                                 array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3786                                 choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3787                 flowCnt = 1;
3788                 for(flowidx=0; flowidx<flowCnt;flowidx++)
3789                 {
3790                         DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3791                                         choice.DRB_Information.flows_Mapped_To_DRB_List.list.\
3792                                         array[flowidx],sizeof(struct Flows_Mapped_To_DRB_Item));
3793                 }
3794                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3795                                 choice.DRB_Information.sNSSAI.sD,sizeof(OCTET_STRING_t));
3796                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3797                                 choice.DRB_Information.sNSSAI.sD->buf,drbSetItem->qoSInformation.\
3798                                 choice.choice_extension->value.choice.DRB_Information.\
3799                                 sNSSAI.sD->size);
3800                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3801                                 choice.DRB_Information.sNSSAI.sST.buf,drbSetItem->qoSInformation.\
3802                                 choice.choice_extension->value.choice.DRB_Information.\
3803                                 sNSSAI.sST.size);
3804                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3805                                 choice.DRB_Information.dRB_QoS.qoS_Characteristics.choice.\
3806                                 non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3807                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.\
3808                                 choice.DRB_Information.dRB_QoS.qoS_Characteristics.choice.\
3809                                 non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3810                 DU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(struct\
3811                                         QoSInformation_ExtIEs));
3812                 for(drbidx=0; drbidx<drbCnt; drbidx++)
3813                 {
3814                         DU_FREE(drbSet->list.array[drbidx],sizeof(struct DRBs_ToBeSetup_ItemIEs));
3815                 }
3816                 DU_FREE(drbSet->list.array,drbSet->list.size);
3817                 RETVALUE(RFAILED);
3818         }
3819         drbSetItem->uLConfiguration->uLUEConfiguration = ULUEConfiguration_no_data;
3820         return ROK;
3821 }/* End of BuildDRBSetup*/
3822
3823 /*******************************************************************
3824  *
3825  * @brief Builds and sends the UE Setup Request
3826  *
3827  * @details
3828  *
3829  *    Function : BuildAndSendUESetReq
3830  *
3831  *    Functionality: Constructs the UE Setup Request and sends
3832  *                   it to the CU through SCTP.
3833  *
3834  * @params[in]
3835  *
3836  * @return ROK     - success
3837  *         RFAILED - failure
3838  *
3839  * ****************************************************************/
3840 S16 BuildAndSendUESetReq()
3841 {
3842         S16  ret;
3843         U8   elementCnt;
3844         U8   cellCnt;
3845         U8   ieId;
3846         U8   idx;
3847         U8   spId;
3848         U8   srbCnt;
3849         U8   srbId;
3850         U8   drbCnt;
3851         U8   drbId;
3852         U8   flowidx;
3853         U8   flowCnt;
3854         U8   ulidx;
3855         U8   ulCnt;
3856         F1AP_PDU_t                                              *f1apMsg = NULL;
3857    UEContextSetupRequest_t                      *ueSetReq;
3858         asn_enc_rval_t                                          encRetVal;        /* Encoder return value */
3859
3860         DU_LOG("\n F1AP : Building UE Context Setup Request\n");
3861
3862         DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
3863         if(f1apMsg == NULLP)
3864         {
3865                 DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
3866                 RETVALUE(RFAILED);
3867         }
3868
3869         f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
3870         DU_ALLOC(f1apMsg->choice.initiatingMessage,
3871                         sizeof(InitiatingMessage_t));
3872         if(f1apMsg->choice.initiatingMessage == NULLP)
3873         {
3874                 DU_LOG(" F1AP : Memory allocation for   F1AP-PDU failed");
3875                 DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
3876                 RETVALUE(RFAILED);
3877         }
3878
3879         f1apMsg->choice.initiatingMessage->procedureCode = \
3880                                                                                                         ProcedureCode_id_UEContextSetup;
3881         f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
3882         f1apMsg->choice.initiatingMessage->value.present = \
3883                                    InitiatingMessage__value_PR_UEContextSetupRequest;
3884         ueSetReq =
3885                 &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3886         elementCnt = 9;
3887         ueSetReq->protocolIEs.list.count = elementCnt;
3888         ueSetReq->protocolIEs.list.size = \
3889                                                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *);
3890
3891         /* Initialize the UESetup members */
3892         DU_ALLOC(ueSetReq->protocolIEs.list.array, \
3893                         elementCnt * sizeof(UEContextSetupRequestIEs_t *));
3894         if(ueSetReq->protocolIEs.list.array == NULLP)
3895         {
3896                 DU_LOG(" F1AP : Memory allocation for UE Context SetupRequest failed");
3897                 DU_FREE(f1apMsg->choice.initiatingMessage,
3898                                 sizeof(InitiatingMessage_t));
3899                 DU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
3900                 RETVALUE(RFAILED);
3901         }
3902
3903         for(idx=0; idx<elementCnt; idx++)
3904         {
3905                 DU_ALLOC(ueSetReq->protocolIEs.list.array[idx],\
3906                                                                                 sizeof(UEContextSetupRequestIEs_t));
3907                 if(ueSetReq->protocolIEs.list.array[idx] == NULLP)
3908                 {
3909                         for(ieId=0; ieId<idx; ieId++)
3910                         {
3911                                 DU_FREE(ueSetReq->protocolIEs.list.array[ieId],\
3912                                                 sizeof(UEContextSetupRequestIEs_t));
3913                         }
3914                         DU_FREE(ueSetReq->protocolIEs.list.array,\
3915                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *));
3916                         DU_FREE(f1apMsg->choice.initiatingMessage,\
3917                                                                                                 sizeof(InitiatingMessage_t));
3918                         DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
3919                         RETVALUE(RFAILED);
3920                 }
3921         }
3922
3923         idx = 0;
3924
3925         /*GNB CU UE F1AP ID*/
3926         ueSetReq->protocolIEs.list.array[idx]->id       = \
3927                                                                                  ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
3928         ueSetReq->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
3929         ueSetReq->protocolIEs.list.array[idx]->value.present = \
3930                                                 UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
3931         ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
3932
3933         /*GNB DU UE F1AP ID*/
3934         idx++;
3935         ueSetReq->protocolIEs.list.array[idx]->id       = \
3936                                                                                  ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
3937         ueSetReq->protocolIEs.list.array[idx]->criticality      =       Criticality_ignore;
3938         ueSetReq->protocolIEs.list.array[idx]->value.present = \
3939                                                 UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
3940         ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
3941
3942         /*Special Cell ID*/
3943         idx++;
3944         ueSetReq->protocolIEs.list.array[idx]->id       = \
3945                                                                                                          ProtocolIE_ID_id_SpCell_ID;
3946         ueSetReq->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
3947         ueSetReq->protocolIEs.list.array[idx]->value.present = \
3948                                                                 UEContextSetupRequestIEs__value_PR_NRCGI;
3949         ret = \
3950         BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3951         if(ret != ROK)
3952         {
3953                 idx =2;
3954                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI.\
3955                         nRCellIdentity.buf,sizeof(ueSetReq->protocolIEs.list.array[idx]->value.\
3956                         choice.NRCGI.nRCellIdentity.size));
3957                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI.\
3958                         pLMN_Identity.buf,sizeof(ueSetReq->protocolIEs.list.array[idx]->value.\
3959                         choice.NRCGI.pLMN_Identity.size));
3960                 for(idx=0; idx<elementCnt; idx++)
3961                 {
3962                         DU_FREE(ueSetReq->protocolIEs.list.array[idx],\
3963                                         sizeof(InitialULRRCMessageTransferIEs_t));
3964                 }
3965                 DU_FREE(ueSetReq->protocolIEs.list.array,\
3966                                 elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *));
3967                 DU_FREE(f1apMsg->choice.initiatingMessage,\
3968                                 sizeof(InitiatingMessage_t));
3969                 DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
3970                 RETVALUE(RFAILED);
3971
3972         }
3973
3974         /*Served Cell Index*/
3975         idx++;
3976         ueSetReq->protocolIEs.list.array[idx]->id       = \
3977                                                                                                  ProtocolIE_ID_id_ServCellIndex;
3978         ueSetReq->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
3979         ueSetReq->protocolIEs.list.array[idx]->value.present = \
3980                                                 UEContextSetupRequestIEs__value_PR_ServCellIndex;
3981         ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
3982         CELL_INDEX;
3983
3984         /*CellULConfigured*/
3985         idx++;
3986         ueSetReq->protocolIEs.list.array[idx]->id       = \
3987                                                                                         ProtocolIE_ID_id_SpCellULConfigured;
3988         ueSetReq->protocolIEs.list.array[idx]->criticality      =       Criticality_ignore;
3989         ueSetReq->protocolIEs.list.array[idx]->value.present = \
3990                                                                         UEContextSetupRequestIEs__value_PR_CellULConfigured;
3991         ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
3992                                                                                                                                                         CellULConfigured_none;
3993
3994
3995         /*CUtoDURRCContainer*/
3996         idx++;
3997         ueSetReq->protocolIEs.list.array[idx]->id       = \
3998                                                                                                   ProtocolIE_ID_id_CUtoDURRCInformation;
3999         ueSetReq->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
4000         ueSetReq->protocolIEs.list.array[idx]->value.present = \
4001                                                 UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
4002
4003         /*Special Cells to be SetupList*/
4004         idx++;
4005         ueSetReq->protocolIEs.list.array[idx]->id       = \
4006                                                                                                   ProtocolIE_ID_id_SCell_ToBeSetup_List;
4007         ueSetReq->protocolIEs.list.array[idx]->criticality      =       Criticality_ignore;
4008         ueSetReq->protocolIEs.list.array[idx]->value.present = \
4009                                                 UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
4010         cellCnt = 1;
4011         ret = BuildSplCellList(&ueSetReq->protocolIEs.\
4012                                         list.array[idx]->value.choice.SCell_ToBeSetup_List);
4013         if(ret != ROK)
4014         {  idx=6;
4015                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4016                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4017                                 SCell_ToBeSetup_Item.sCell_ID.nRCellIdentity.buf,\
4018                                 ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4019                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4020                                 SCell_ToBeSetup_Item.sCell_ID.nRCellIdentity.size);
4021                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4022                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4023                                 SCell_ToBeSetup_Item.sCell_ID.pLMN_Identity.buf,\
4024                                 ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4025                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4026                                 SCell_ToBeSetup_Item.sCell_ID.pLMN_Identity.size);
4027                 for(spId=0; spId<cellCnt; spId++)
4028                 {
4029                         DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4030                                         SCell_ToBeSetup_List.list.array[spId],sizeof(struct
4031                                                 SCell_ToBeSetup_ItemIEs));
4032                 }
4033                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4034                                 SCell_ToBeSetup_List.list.array,ueSetReq->protocolIEs.list.\
4035                                 array[idx]->value.choice.SCell_ToBeSetup_List.list.size);
4036                 idx =2;
4037                 idx=idx-4;
4038                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI.\
4039                                 nRCellIdentity.buf,sizeof(ueSetReq->protocolIEs.list.array[idx]->value.\
4040                                         choice.NRCGI.nRCellIdentity.size));
4041                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI.\
4042                                 pLMN_Identity.buf,sizeof(ueSetReq->protocolIEs.list.array[idx]->value.\
4043                                         choice.NRCGI.pLMN_Identity.size));
4044                 for(idx=0; idx<elementCnt; idx++)
4045                 {
4046                         DU_FREE(ueSetReq->protocolIEs.list.array[idx],\
4047                                         sizeof(UEContextSetupRequestIEs_t));
4048                 }
4049                 DU_FREE(ueSetReq->protocolIEs.list.array,\
4050                                 elementCnt * sizeof(UEContextSetupRequestIEs_t *));
4051                 DU_FREE(f1apMsg->choice.initiatingMessage,\
4052                                 sizeof(InitiatingMessage_t));
4053                 DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
4054                 RETVALUE(RFAILED);
4055         }
4056         /*SRBs To Be Setup List*/
4057         idx++;
4058         ueSetReq->protocolIEs.list.array[idx]->id       = \
4059                                                                                  ProtocolIE_ID_id_SRBs_ToBeSetup_List;
4060         ueSetReq->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
4061         ueSetReq->protocolIEs.list.array[idx]->value.present = \
4062                                                 UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
4063         srbCnt = 1;
4064         ret =   BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.\
4065                                                                                                                         choice.SRBs_ToBeSetup_List);
4066         if(ret != ROK)
4067         {
4068                 idx =7;
4069                 for(srbId=0; srbId<srbCnt; srbId++)
4070                 {
4071                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4072                                 SRBs_ToBeSetup_List.list.array[srbId],\
4073                                 sizeof(struct SRBs_ToBeSetup_ItemIEs));
4074                 }
4075                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4076                                 SRBs_ToBeSetup_List.list.array,ueSetReq->protocolIEs.list.\
4077                                 array[idx]->value.choice.SRBs_ToBeSetup_List.list.size);
4078                 idx=6;
4079                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4080                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4081                                 SCell_ToBeSetup_Item.sCell_ID.nRCellIdentity.buf,\
4082                                 ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4083                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4084                                 SCell_ToBeSetup_Item.sCell_ID.nRCellIdentity.size);
4085                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4086                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4087                                 SCell_ToBeSetup_Item.sCell_ID.pLMN_Identity.buf,\
4088                                 ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4089                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4090                                 SCell_ToBeSetup_Item.sCell_ID.pLMN_Identity.size);
4091                 for(spId=0; spId<cellCnt; spId++)
4092                 {
4093                         DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4094                                         SCell_ToBeSetup_List.list.array[spId],sizeof(struct
4095                                                 SCell_ToBeSetup_ItemIEs));
4096                 }
4097                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4098                                 SCell_ToBeSetup_List.list.array,ueSetReq->protocolIEs.list.\
4099                                 array[idx]->value.choice.SCell_ToBeSetup_List.list.size);
4100                 idx=2;
4101                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI.\
4102                         nRCellIdentity.buf,sizeof(ueSetReq->protocolIEs.list.array[idx]->value.\
4103                         choice.NRCGI.nRCellIdentity.size));
4104                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI.\
4105                         pLMN_Identity.buf,sizeof(ueSetReq->protocolIEs.list.array[idx]->value.\
4106                         choice.NRCGI.pLMN_Identity.size));
4107                 for(idx=0; idx<elementCnt; idx++)
4108                 {
4109                         DU_FREE(ueSetReq->protocolIEs.list.array[idx],\
4110                                         sizeof(UEContextSetupRequestIEs_t));
4111                 }
4112                 DU_FREE(ueSetReq->protocolIEs.list.array,\
4113                                 elementCnt * sizeof(UEContextSetupRequestIEs_t *));
4114                 DU_FREE(f1apMsg->choice.initiatingMessage,\
4115                                 sizeof(InitiatingMessage_t));
4116                 DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
4117                 RETVALUE(RFAILED);
4118         }
4119         /*DRBs to Be Setup List*/
4120         idx++;
4121         ueSetReq->protocolIEs.list.array[idx]->id       = \
4122                                                                                  ProtocolIE_ID_id_DRBs_ToBeSetup_List;
4123         ueSetReq->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
4124         ueSetReq->protocolIEs.list.array[idx]->value.present = \
4125                                                 UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
4126         drbCnt = 1;
4127         flowCnt = 1;
4128         ulCnt = 1;
4129         ret = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.\
4130                                                                                                                         choice.DRBs_ToBeSetup_List);
4131         if(ret != ROK)
4132         {       idx=8;
4133                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4134                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4135                                 DRBs_ToBeSetup_Item.uLConfiguration,\
4136                                 sizeof(struct ULConfiguration));
4137                 ulidx=0;
4138                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4139                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4140                                 DRBs_ToBeSetup_Item.uLUPTNLInformation_ToBeSetup_List.list.\
4141                                 array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
4142                                 sizeof(struct GTPTunnel));
4143                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4144                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4145                                 DRBs_ToBeSetup_Item.uLUPTNLInformation_ToBeSetup_List.list.\
4146                                 array,ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4147                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4148                                 DRBs_ToBeSetup_Item.uLUPTNLInformation_ToBeSetup_List.list.size);
4149                 for(ulidx=0; ulidx<ulCnt;ulidx++)
4150                 {
4151                         DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4152                                         DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4153                                         DRBs_ToBeSetup_Item.uLUPTNLInformation_ToBeSetup_List.list.\
4154                                         array[ulidx],sizeof(struct ULUPTNLInformation_ToBeSetup_Item));
4155                 }
4156                 flowidx = 0;
4157                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4158                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4159                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4160                                 choice_extension->value.choice.DRB_Information.\
4161                                 flows_Mapped_To_DRB_List.list.array[idx]->qoSFlowLevelQoSParameters.\
4162                                 qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
4163                                 sizeof(AveragingWindow_t));
4164                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4165                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4166                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4167                                 choice_extension->value.choice.DRB_Information.\
4168                                 flows_Mapped_To_DRB_List.list.array[idx]->qoSFlowLevelQoSParameters.\
4169                                 qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
4170                                 sizeof(MaxDataBurstVolume_t));
4171                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4172                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4173                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4174                                 choice_extension->value.choice.DRB_Information.\
4175                                 flows_Mapped_To_DRB_List.list.array,ueSetReq->protocolIEs.list.\
4176                                 array[idx]->value.choice.\
4177                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4178                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4179                                 choice_extension->value.choice.DRB_Information.\
4180                                 flows_Mapped_To_DRB_List.list.size);
4181            for(flowidx=0;flowidx<flowCnt;flowidx++)
4182                 {
4183                         DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4184                                         DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4185                                         DRBs_ToBeSetup_Item.qoSInformation.choice.\
4186                                         choice_extension->value.choice.DRB_Information.\
4187                                         flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(struct
4188                                         Flows_Mapped_To_DRB_Item));
4189                 }
4190                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4191                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4192                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4193                                 choice_extension->value.choice.DRB_Information.sNSSAI.\
4194                                 sD->buf,ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4195                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4196                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4197                                 choice_extension->value.choice.DRB_Information.sNSSAI.\
4198                                 sD->size);
4199                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4200                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4201                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4202                                 choice_extension->value.choice.DRB_Information.sNSSAI.\
4203                                 sD,sizeof(OCTET_STRING_t));
4204                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4205                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4206                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4207                                 choice_extension->value.choice.DRB_Information.sNSSAI.\
4208                                 sST.buf,ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4209                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4210                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4211                                 choice_extension->value.choice.DRB_Information.sNSSAI.\
4212                                 sST.size);
4213                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4214                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4215                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4216                                 choice_extension->value.choice.DRB_Information.dRB_QoS.\
4217                                 qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
4218                                 sizeof(MaxDataBurstVolume_t));
4219                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4220                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4221                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4222                                 choice_extension->value.choice.DRB_Information.dRB_QoS.\
4223                                 qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
4224                                 sizeof(AveragingWindow_t));
4225                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4226                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4227                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4228                                 choice_extension->value.choice.DRB_Information.dRB_QoS.\
4229                                 qoS_Characteristics.choice.non_Dynamic_5QI,\
4230                                 sizeof(NonDynamic5QIDescriptor_t));
4231                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4232                                 DRBs_ToBeSetup_List.list.array[0]->value.choice.\
4233                                 DRBs_ToBeSetup_Item.qoSInformation.choice.\
4234                                 choice_extension,sizeof(struct QoSInformation_ExtIEs));
4235                 for(drbId=0; drbId<drbCnt; drbId++)
4236                 {
4237                         DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4238                                         DRBs_ToBeSetup_List.list.array[drbId],\
4239                                         sizeof(struct DRBs_ToBeSetup_ItemIEs));
4240                 }
4241                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4242                                 DRBs_ToBeSetup_List.list.array,ueSetReq->protocolIEs.list.\
4243                                 array[idx]->value.choice.DRBs_ToBeSetup_List.list.size);
4244                 idx=7;
4245                 for(srbId=0; srbId<srbCnt; srbId++)
4246                 {
4247                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4248                                 SRBs_ToBeSetup_List.list.array[srbId],\
4249                                 sizeof(struct SRBs_ToBeSetup_ItemIEs));
4250                 }
4251                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4252                                 SRBs_ToBeSetup_List.list.array,ueSetReq->protocolIEs.list.\
4253                                 array[idx]->value.choice.SRBs_ToBeSetup_List.list.size);
4254                 idx=6;
4255                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4256                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4257                                 SCell_ToBeSetup_Item.sCell_ID.nRCellIdentity.buf,\
4258                                 ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4259                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4260                                 SCell_ToBeSetup_Item.sCell_ID.nRCellIdentity.size);
4261                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4262                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4263                                 SCell_ToBeSetup_Item.sCell_ID.pLMN_Identity.buf,\
4264                                 ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4265                                 SCell_ToBeSetup_List.list.array[0]->value.choice.\
4266                                 SCell_ToBeSetup_Item.sCell_ID.pLMN_Identity.size);
4267                 for(spId=0; spId<cellCnt; spId++)
4268                 {
4269                         DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4270                                         SCell_ToBeSetup_List.list.array[spId],sizeof(struct
4271                                                 SCell_ToBeSetup_ItemIEs));
4272                 }
4273                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.\
4274                                 SCell_ToBeSetup_List.list.array,ueSetReq->protocolIEs.list.\
4275                                 array[idx]->value.choice.SCell_ToBeSetup_List.list.size);
4276                 idx =2;
4277                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI.\
4278                         nRCellIdentity.buf,sizeof(ueSetReq->protocolIEs.list.array[idx]->value.\
4279                         choice.NRCGI.nRCellIdentity.size));
4280                 DU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI.\
4281                         pLMN_Identity.buf,sizeof(ueSetReq->protocolIEs.list.array[idx]->value.\
4282                         choice.NRCGI.pLMN_Identity.size));
4283                 for(idx=0; idx<elementCnt; idx++)
4284                 {
4285                         DU_FREE(ueSetReq->protocolIEs.list.array[idx],\
4286                                         sizeof(UEContextSetupRequestIEs_t));
4287                 }
4288                 DU_FREE(ueSetReq->protocolIEs.list.array,\
4289                                 elementCnt * sizeof(UEContextSetupRequestIEs_t *));
4290                 DU_FREE(f1apMsg->choice.initiatingMessage,\
4291                                 sizeof(InitiatingMessage_t));
4292                 DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
4293                 RETVALUE(RFAILED);
4294         }
4295
4296         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
4297
4298         /* Encode the F1SetupRequest type as APER */
4299         cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
4300         encBufSize = 0;
4301         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
4302                         encBuf);
4303         /* Encode results */
4304         if(encRetVal.encoded == ENCODE_FAIL)
4305         {
4306                 DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
4307                                 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4308                 RETVALUE(RFAILED);
4309         }
4310         else
4311         {
4312                 DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
4313                 for(int i=0; i< encBufSize; i++)
4314                 {
4315                         printf("%x",encBuf[i]);
4316                 }
4317         }
4318
4319         /* Sending  msg  */
4320         if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL)       !=      ROK)
4321         {
4322                 DU_LOG("\n F1AP : Sending       UE Context Setup Request Failed");
4323                 RETVALUE(RFAILED);
4324         }
4325         return ROK;
4326 }/* End of BuildAndSendUESetReq*/
4327
4328 /*******************************************************************
4329 *
4330 * @brief Handles received F1AP message and sends back response
4331 *
4332 * @details
4333 *
4334 *    Function : F1APMsgHdlr
4335 *
4336 *    Functionality:
4337 *         - Decodes received F1AP control message
4338 *         - Prepares response message, encodes and sends to SCTP
4339 *
4340 * @params[in]
4341 * @return ROK     - success
4342 *         RFAILED - failure
4343 *
4344 * ****************************************************************/
4345 void F1APMsgHdlr(Buffer *mBuf)
4346 {
4347    int i;
4348    char *recvBuf;
4349    MsgLen copyCnt;
4350    MsgLen recvBufLen;
4351    F1AP_PDU_t *f1apMsg;
4352    asn_dec_rval_t rval; /* Decoder return value */
4353    F1AP_PDU_t f1apasnmsg ;
4354
4355    DU_LOG("\nF1AP : Received F1AP message buffer");
4356    SPrntMsg(mBuf, 0,0);
4357
4358    /* Copy mBuf into char array to decode it */
4359    SFndLenMsg(mBuf, &recvBufLen);
4360    if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK)
4361    {
4362       DU_LOG("\nF1AP : Memory allocation failed");
4363       return;
4364    }
4365    if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
4366    {
4367       DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
4368       return;
4369    }
4370
4371    printf("\nF1AP : Received flat buffer to be decoded : ");
4372    for(i=0; i< recvBufLen; i++)
4373    {
4374         printf("%x",recvBuf[i]);
4375    }
4376
4377    /* Decoding flat buffer into F1AP messsage */
4378    f1apMsg = &f1apasnmsg;
4379    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
4380
4381    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
4382    SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen);
4383    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
4384    {
4385       DU_LOG("\nF1AP : ASN decode failed");
4386       return;
4387    }
4388    printf("\n");
4389    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
4390
4391    switch(f1apMsg->present)
4392    {
4393       case F1AP_PDU_PR_successfulOutcome:
4394       {
4395          switch(f1apMsg->choice.successfulOutcome->value.present)
4396          {
4397             case SuccessfulOutcome__value_PR_F1SetupResponse:
4398             {
4399 #ifndef ODU_TEST_STUB
4400                procF1SetupRsp(f1apMsg);
4401 #endif
4402                break;
4403             }
4404
4405             case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
4406             {
4407                procGNBDUCfgUpdAck(f1apMsg);
4408                break;
4409             }
4410
4411             default:
4412             {
4413                DU_LOG("\nF1AP : Invalid type of successful outcome [%d]", f1apMsg->choice.successfulOutcome->value.present);
4414                return;
4415             }
4416          }/* End of switch(successfulOutcome) */
4417          break;
4418       }
4419
4420       default:
4421       {
4422          DU_LOG("\nF1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
4423          return;
4424       }
4425
4426    }/* End of switch(f1apMsg->present) */
4427
4428 } /* End of F1APMsgHdlr */
4429
4430 /*******************************************************************
4431  *
4432  * @brief Processes GNB DU config update ack
4433  *
4434  * @details
4435  *
4436  *    Function : procGNBDUCfgUpdAck
4437  *
4438  *    Functionality: Processes GNB DU config update ack
4439  *
4440  * @params[in] F1AP_PDU_t ASN decoded F1AP message
4441  * @return ROK     - success
4442  *         RFAILED - failure
4443  *
4444  * ****************************************************************/
4445
4446 S16 procGNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
4447 {
4448
4449
4450    DU_LOG("\nF1AP : GNB-DU config update acknowledgment received");
4451
4452
4453    /* TODO :Check the deallocation */
4454 #if 0
4455    SPutSBuf(DU_APP_MEM_REGION,DU_POOL,(Data *)&(gNBDuCfgAck->protocolIEs.list.array),\
4456            (Size)elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
4457    SPutSBuf(DU_APP_MEM_REGION,DU_POOL,(Data *)&(f1apMsg->choice.successfulOutcome),\
4458            (Size)sizeof(SuccessfulOutcome_t));
4459    SPutSBuf(DU_APP_MEM_REGION,DU_POOL,(Data *)&f1apMsg,(Size)sizeof(F1AP_PDU_t));
4460 #endif
4461     return ROK;
4462 }
4463
4464 /**********************************************************************
4465   End of file
4466  **********************************************************************/