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