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