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