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