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