src/du_app/du_f1ap_msg_hdl.c

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