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 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "BWP-Downlink.h"
  67 #include "PUSCH-TimeDomainResourceAllocation.h"
  68 #include "PUSCH-TimeDomainResourceAllocationList.h"
  69 #include "DMRS-UplinkConfig.h"
  70 #include "PUSCH-Config.h"
  71 #include "SRS-ResourceId.h"
  72 #include "SRS-Resource.h"
  73 #include "SRS-ResourceSet.h"
  74 #include "SRS-Config.h"
  75 #include "BWP-UplinkDedicated.h"
  76 #include "PUSCH-ServingCellConfig.h"
  77 #include "UplinkConfig.h"
  78 #include "DUtoCURRCContainer.h"
  79 #include "GBR-QoSFlowInformation.h"
  80 #include "QoSFlowLevelQoSParameters.h"
  81 #include "PUCCH-Config.h"
  82 #include "PUCCH-ResourceSet.h"
  83 #include "PUCCH-Resource.h"
  84 #include "PUCCH-PowerControl.h"
  85 #include "P0-PUCCH.h"
  86 #include "PUCCH-PathlossReferenceRS.h"
  87 #include "PUCCH-format0.h"
  88 #include "PUCCH-format1.h"
  89 #include "PUCCH-format2.h"
  90 #include "PUCCH-format3.h"
  91 #include "PUCCH-format4.h"
  92 #include "PUCCH-FormatConfig.h"
  93 #include "SchedulingRequestResourceConfig.h"
  94 #include<ProtocolIE-Field.h>
  95 #include "ProtocolExtensionField.h"
  96 #include "odu_common_codec.h"
  97 #include "du_mgr.h"
  98 #include "du_cell_mgr.h"
  99 #include "du_f1ap_msg_hdl.h"
 100 #include "DRBs-Setup-Item.h"
 101 #include "DLUPTNLInformation-ToBeSetup-List.h"
 102 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 103 #include "UPTransportLayerInformation.h"
 104 #include "GTPTunnel.h"
 105 #include "SupportedSULFreqBandItem.h"
 106 #include "du_sys_info_hdl.h"
 107 #include "du_e2ap_msg_hdl.h"
 108 #include "du_f1ap_conversions.h"
 109
 110 #ifdef O1_ENABLE
 111 #include "CmInterface.h"
 112 extern StartupConfig g_cfg;
 113 #endif
 114
 115 DuCfgParams duCfgParam;
 116
 117 /******************************************************************
 118  *
 119  * @brief Function to fetch lcId based on DRB Id
 120  *
 121  * @details
 122  *
 123  *    Function : fetchLcId
 124  *
 125  *    @params[in] drbId
 126  *
 127  *    Functionality: Function to fetch lcId based on DRB Id
 128  *
 129  * Returns: lcId - SUCCESS
 130  *          RFAILED - FAILURE
 131  *****************************************************************/
 132
 133 uint8_t fetchLcId(uint8_t drbId)
 134 {
 135    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 136
 137    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 138    {
 139       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 140       {
 141          if(duCb.actvCellLst[cellIdx] != NULLP)
 142          {
 143             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.numLcs;
 144             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 145             {
 146                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbId == drbId && \
 147                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbType == RB_TYPE_DRB)
 148                {
 149                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].lcId;
 150                   return lcId;
 151                }
 152             }
 153          }
 154       }
 155    }
 156    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 157    return RFAILED;
 158 }
 159
 160 /*******************************************************************
 161 *
 162 * @brief Adding F1AP pdu to reserved pdu list
 163 *
 164 * @details
 165 *
 166 *    Function : addToReservedF1apPduList
 167 *
 168 *    Functionality: Adding F1AP pdu to reserved pdu list.
 169 *     These pdu are awaiting aknowledgment from CU
 170 *
 171 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 172 *
 173 * @return ROK - success
 174 *         RFAILED - failure
 175 *
 176 * ****************************************************************/
 177 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 178 {
 179    CmLList         *node = NULLP;
 180    ReservedF1apPduInfo *pduInfo = NULLP;
 181    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 182    if(pduInfo)
 183    {
 184       DU_ALLOC(node, sizeof(CmLList));
 185       if(node)
 186       {
 187          pduInfo->transId = transId;
 188          pduInfo->f1apMsg = (void*) f1apPdu;
 189
 190          node->node = (PTR)pduInfo;
 191          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 192       }
 193    }
 194 }
 195
 196 /*******************************************************************
 197 *
 198 * @brief searching for F1AP pdu from ReservedF1apPduList
 199 *
 200 * @details
 201 *
 202 *    Function : searchFromReservedF1apPduList
 203 *
 204 *    Functionality: searching for F1AP pdu information
 205 *
 206 * @params[in] uint8_t transId
 207 *
 208 * @return pointer to F1AP_PDU_t
 209 *
 210 * ****************************************************************/
 211
 212 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 213 {
 214    CmLList         *node;
 215    ReservedF1apPduInfo *f1apPdu;
 216    if(duCb.reservedF1apPduList.count)
 217    {
 218       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 219       while(node)
 220       {
 221          f1apPdu = (ReservedF1apPduInfo*)node->node;
 222          if(f1apPdu->transId == transId)
 223          {
 224             return node;
 225          }
 226          node = node->next;
 227       }
 228    }
 229    return NULL;
 230 }
 231
 232 /*******************************************************************
 233 *
 234 * @brief deleting F1AP pdu information from ReservedF1apPduList
 235 *
 236 * @details
 237 *
 238 *    Function : deleteFromReservedF1apPduList
 239 *
 240 *    Functionality: deleting pdu information from ReservedF1apPduList
 241 *
 242 * @params[in] CmLList *node
 243 *
 244 * @return void
 245 *
 246 * ****************************************************************/
 247
 248 void deleteFromReservedF1apPduList(CmLList *node)
 249 {
 250    ReservedF1apPduInfo *f1apPdu;
 251
 252    if(node != NULL)
 253    {
 254       f1apPdu = (ReservedF1apPduInfo *)node->node;
 255       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 256       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 257       DU_FREE(node, sizeof(CmLList));
 258       node = NULL;
 259    }
 260 }
 261
 262 /*******************************************************************
 263  *
 264  * @brief Builds Uplink Info for NR
 265  *
 266  * @details
 267  *
 268  *    Function : BuildULNRInfo
 269  *
 270  *    Functionality: Building NR Uplink Info
 271  *
 272  * @params[in] NRFreqInfo_t *ulnrfreq
 273  * @return ROK     - success
 274  *         RFAILED - failure
 275  *
 276  * ****************************************************************/
 277 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 278 {
 279    uint8_t idx=0;
 280    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 281                        fdd.ulNrFreqInfo.nrArfcn;
 282    ulnrfreq->freqBandListNr.list.count = 1;
 283    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 284    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 285    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 286    {
 287       return RFAILED;
 288    }
 289    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 290    {
 291       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 292       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 293       {
 294          return RFAILED;
 295       }
 296    }
 297    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 298                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 299                                                                  freqBand[0].nrFreqBand;
 300    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 301    return ROK;
 302 }
 303 /*******************************************************************
 304  *
 305  * @brief Builds Downlink NR Info
 306  *
 307  * @details
 308  *
 309  *    Function : BuildDLNRInfo
 310  *
 311  *    Functionality: Building Downlink NR Info
 312  *
 313  * @params[in] NRFreqInfo_t *dlnrfreq
 314  * @return ROK     - success
 315  *         RFAILED - failure
 316  *
 317  * ****************************************************************/
 318 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 319 {
 320    uint8_t idx=0;
 321    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 322                        fdd.dlNrFreqInfo.nrArfcn;
 323    dlnrfreq->freqBandListNr.list.count = 1;
 324    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 325    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 326    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 327    {
 328       return RFAILED;
 329    }
 330    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 331    {
 332       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 333       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 334       {
 335          return RFAILED;
 336       }
 337    }
 338    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 339                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 340                                                                  freqBand[0].nrFreqBand;
 341    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 342
 343    return ROK;
 344 }
 345
 346 /*******************************************************************
 347  *
 348  * @brief Builds NRCell ID
 349  *
 350  * @details
 351  *
 352  *    Function : BuildNrCellId
 353  *
 354  *    Functionality: Building the NR Cell ID
 355  *
 356  * @params[in] BIT_STRING_t *nrcell
 357  * @return ROK     - success
 358  *         RFAILED - failure
 359  *
 360  * ****************************************************************/
 361
 362 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 363 {
 364    memset(nrcell->buf, 0, nrcell->size);
 365    nrcell->buf[4]   = duCfgParam.sib1Params.cellIdentity;
 366    nrcell->bits_unused = 4;
 367    return ROK;
 368 }
 369
 370 /*******************************************************************
 371  *
 372  * @brief Builds Nrcgi
 373  *
 374  * @details
 375  *
 376  *    Function : BuildNrcgi
 377  *
 378  *    Functionality: Building the PLMN ID and NR Cell id
 379  *
 380  * @params[in] NRCGI_t *nrcgi
 381  * @return ROK     - success
 382  *         RFAILED - failure
 383  *
 384  * ****************************************************************/
 385 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 386 {
 387    uint8_t ret;
 388    uint8_t byteSize = 5;
 389    /* Allocate Buffer Memory */
 390    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 391    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 392    if(nrcgi->pLMN_Identity.buf == NULLP)
 393    {
 394       return RFAILED;
 395    }
 396    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 397          nrcgi->pLMN_Identity.buf); // Building PLMN function
 398    if(ret != ROK)
 399    {
 400       return RFAILED;
 401    }
 402    /*nrCellIdentity*/
 403    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 404    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 405    if(nrcgi->nRCellIdentity.buf == NULLP)
 406    {
 407       return RFAILED;
 408    }
 409    BuildNrCellId(&nrcgi->nRCellIdentity);
 410
 411    return ROK;
 412 }
 413 /*******************************************************************
 414  *
 415  * @brief Builds FiveGStac
 416  *
 417  * @details
 418  *
 419  *    Function : BuildFiveGSTac
 420  *
 421  *    Functionality: Building the FiveGSTac
 422  *
 423  * @params[in] OCTET_STRING_t *fivegsTac
 424  * @return ROK     - success
 425  *         RFAILED - failure
 426  *
 427  * ****************************************************************/
 428 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 429 {
 430    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 431    if(servcell->fiveGS_TAC == NULLP)
 432    {
 433       return RFAILED;
 434    }
 435    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 436    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 437          sizeof(servcell->fiveGS_TAC->size));
 438    if(servcell->fiveGS_TAC->buf == NULLP)
 439    {
 440       return RFAILED;
 441    }
 442    servcell->fiveGS_TAC->buf[0] = 0;
 443    servcell->fiveGS_TAC->buf[1] = 0;
 444    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 445    return ROK;
 446 }
 447
 448 /*******************************************************************
 449  *
 450  * @brief fill nr frequency information
 451  *
 452  * @details
 453  *
 454  *    Function : fillNrTddInfo
 455  *
 456  *    Functionality: fill nr frequency information
 457  *
 458  * @params[in] NRFreqInfo_t freqInfo
 459  * @return ROK     - success
 460  *         RFAILED - failure
 461  *
 462  * ****************************************************************/
 463 uint8_t fillNrTddInfo(TDD_Info_t *tddInfo)
 464 {
 465    uint8_t elementCnt = 1, freqBandListIdx = 0, supportedBandIdx = 0;
 466    NRFreqInfo_t *freqInfo = NULLP;
 467
 468    if(tddInfo == NULLP)
 469    {
 470       DU_LOG("\nERROR  --> DU APP : Null pointer received at fillNrTddInfo");
 471       return RFAILED;
 472    }
 473
 474    freqInfo = &tddInfo->nRFreqInfo;
 475    freqInfo->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn;
 476
 477    freqInfo->freqBandListNr.list.count = elementCnt;
 478    freqInfo->freqBandListNr.list.size = freqInfo->freqBandListNr.list.count  * sizeof(FreqBandNrItem_t *);
 479    DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
 480    if(!freqInfo->freqBandListNr.list.array)
 481    {
 482       DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 483       return RFAILED;
 484    }
 485
 486    for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
 487    {
 488       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
 489       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
 490       {
 491          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 492          return RFAILED;
 493       }
 494
 495       freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
 496       f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
 497       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
 498       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
 499       supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
 500
 501       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
 502             freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
 503       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
 504       {
 505          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 506          return RFAILED;
 507       }
 508
 509       for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
 510       {
 511          DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
 512                sizeof(SupportedSULFreqBandItem_t));
 513          if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
 514          {
 515             DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 516             return RFAILED;
 517          }
 518
 519          freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx]->freqBandIndicatorNr =\
 520          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.freqBand[0].sulBand[0];
 521       }
 522    }
 523
 524    tddInfo->transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs;
 525    tddInfo->transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb;
 526
 527    return ROK;
 528 }
 529
 530 /*******************************************************************
 531  *
 532  * @brief Builds NR Mode
 533  *
 534  * @details
 535  *
 536  *    Function : BuildNrMode
 537  *
 538  *    Functionality: Building the NR Mode
 539  *
 540  * @params[in] NR_Mode_Info_t *fdd
 541  * @return ROK     - success
 542  *         RFAILED - failure
 543  *
 544  * ****************************************************************/
 545 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 546 {
 547    uint8_t BuildDLNRInforet=0;
 548    uint8_t BuildULNRInforet=0;
 549
 550 #ifdef NR_TDD
 551    mode->present = NR_Mode_Info_PR_tDD;
 552 #else
 553    mode->present = NR_Mode_Info_PR_fDD;
 554 #endif
 555
 556    if(mode->present == NR_Mode_Info_PR_fDD)
 557    {
 558       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 559       if(mode->choice.fDD == NULLP)
 560       {
 561          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 562          return RFAILED;
 563       }
 564       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 565       if(BuildULNRInforet != ROK)
 566       {
 567          DU_LOG("\nERROR  --> Failed to build UlNrFreqInfo");
 568          return RFAILED;
 569       }
 570       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 571       if(BuildDLNRInforet != ROK)
 572       {
 573          DU_LOG("\nERROR  --> Failed to build DlNrFreqInfo");
 574          return RFAILED;
 575       }
 576       mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 577                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 578                                                           f1Mode.mode.fdd.ulTxBw.nrScs;
 579       mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 580                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 581                                                           f1Mode.mode.fdd.ulTxBw.nrb;
 582       mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 583                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 584                                                           f1Mode.mode.fdd.dlTxBw.nrScs;
 585       mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 586                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 587                                                           f1Mode.mode.fdd.dlTxBw.nrb;
 588    }
 589    else if(mode->present == NR_Mode_Info_PR_tDD)
 590    {
 591       DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
 592       if(mode->choice.tDD == NULLP)
 593       {
 594          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 595          return RFAILED;
 596       }
 597
 598       if(fillNrTddInfo(mode->choice.tDD) != ROK)
 599       {
 600          DU_LOG("\nERROR  --> Failed to fill Nr TDD information");
 601          return RFAILED;
 602       }
 603
 604    }
 605
 606    return ROK;
 607 }
 608 /*******************************************************************
 609  *
 610  * @brief Builds IE Extensions for Served PLMNs
 611  *
 612  * @details
 613  *
 614  *    Function : BuildExtensions
 615  *
 616  *    Functionality: Building the IE Extensions
 617  *
 618  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 619  * @return ROK     - success
 620  *         RFAILED - failure
 621  *
 622  * ****************************************************************/
 623 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 624 {
 625    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 626    uint8_t elementCnt=0, extensionCnt=0;
 627
 628    extensionCnt=IE_EXTENSION_LIST_COUNT;
 629    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 630    if((*ieExtend) == NULLP)
 631    {
 632       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 633       return RFAILED;
 634    }
 635    (*ieExtend)->list.count = extensionCnt;
 636    (*ieExtend)->list.size = \
 637                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 638    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 639    if((*ieExtend)->list.array == NULLP)
 640    {
 641       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 642       return RFAILED;
 643    }
 644    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 645    {
 646       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 647             sizeof(ServedPLMNs_ItemExtIEs_t));
 648       if((*ieExtend)->list.array[plmnidx] == NULLP)
 649       {
 650          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 651          return RFAILED;
 652       }
 653    }
 654
 655    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 656    idx = 0;
 657    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 658    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 659    (*ieExtend)->list.array[idx]->extensionValue.present = \
 660    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 661    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 662       list.count = elementCnt;
 663    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 664       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 665       list.count * sizeof(SliceSupportItem_t *);
 666
 667    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 668          list.array, elementCnt * sizeof(SliceSupportItem_t *));
 669    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 670          list.array == NULLP)
 671    {
 672       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 673       return RFAILED;
 674    }
 675
 676    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
 677    {
 678       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 679             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
 680       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 681             list.array[sliceLstIdx] == NULLP)
 682       {
 683          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 684          return RFAILED;
 685       }
 686       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 687          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
 688       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 689             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 690             extensionValue.choice.SliceSupportList.\
 691             list.array[sliceLstIdx]->sNSSAI.sST.size);
 692       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 693             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
 694       {
 695          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 696          return RFAILED;
 697       }
 698       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 699          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
 700          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
 701
 702       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 703             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 704       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 705             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
 706       {
 707          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 708          return RFAILED;
 709       }
 710       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 711          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
 712       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 713             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
 714             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 715       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 716             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
 717       {
 718          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 719          return RFAILED;
 720       }
 721       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 722       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
 723       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
 724       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 725    }
 726    return ROK;
 727 }
 728 /*******************************************************************
 729  *
 730  * @brief Builds Served PLMN
 731  *
 732  * @details
 733  *
 734  *    Function : BuildServedPlmn
 735  *
 736  *    Functionality: Building the Served PLMN
 737  *
 738  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 739  * @return ROK     - success
 740  *         RFAILED - failure
 741  *
 742  * ****************************************************************/
 743 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 744 {
 745    uint8_t  plmnidx;
 746    uint8_t  servPlmnCnt=1;
 747    uint8_t buildPlmnIdret=0;
 748    uint8_t BuildExtensionsret=0;
 749    srvplmn->list.count = servPlmnCnt;
 750    srvplmn->list.size = \
 751                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 752    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 753    if(srvplmn->list.array == NULLP)
 754    {
 755       return RFAILED;
 756    }
 757    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 758    {
 759       DU_ALLOC(srvplmn->list.array[plmnidx],\
 760             sizeof(ServedPLMNs_Item_t));
 761       if(srvplmn->list.array[plmnidx] == NULLP)
 762       {
 763          return RFAILED;
 764       }
 765    }
 766    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 767    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 768    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 769          srvplmn->list.array[0]->pLMN_Identity.buf);
 770    if(buildPlmnIdret!= ROK)
 771    {
 772       return RFAILED;
 773    }
 774    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 775    if(BuildExtensionsret!= ROK)
 776    {
 777       return RFAILED;
 778    }
 779    return ROK;
 780 }
 781 /*******************************************************************
 782  *
 783  * @brief Builds Served Cell List
 784  *
 785  * @details
 786  *
 787  *    Function : BuildServedCellList
 788  *
 789  *    Functionality: Building Served Cell List
 790  *
 791  * @params[in] PLMNID plmn
 792  * @return ROK     - success
 793  *         RFAILED - failure
 794  *
 795  * ****************************************************************/
 796
 797 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 798 {
 799    uint8_t  BuildNrcgiret=0;
 800    uint8_t  BuildFiveGSTacret=0;
 801    uint8_t  BuildServedPlmnret=0;
 802    uint8_t  BuildNrModeret=0;
 803    uint8_t  idx;
 804    uint8_t  plmnidx;
 805    uint8_t  plmnCnt=1;
 806    GNB_DU_Served_Cells_Item_t *srvCellItem;
 807    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 808    duServedCell->list.count = plmnCnt;
 809
 810    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
 811    if(duServedCell->list.array == NULLP)
 812    {
 813       return RFAILED;
 814    }
 815    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 816    {
 817       DU_ALLOC(duServedCell->list.array[plmnidx],\
 818             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 819       if(duServedCell->list.array[plmnidx] == NULLP)
 820       {
 821          return RFAILED;
 822       }
 823    }
 824    idx = 0;
 825    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 826    duServedCell->list.array[idx]->criticality = Criticality_reject;
 827    duServedCell->list.array[idx]->value.present = \
 828                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 829    srvCellItem = \
 830                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 831    /*nRCGI*/
 832    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 833    if(BuildNrcgiret != ROK)
 834    {
 835       return RFAILED;
 836    }
 837    /*nRPCI*/
 838    srvCellItem->served_Cell_Information.nRPCI = \
 839                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 840
 841    /*fiveGS_TAC*/
 842    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 843    if(BuildFiveGSTacret != ROK)
 844    {
 845       return RFAILED;
 846    }
 847    /*Served PLMNs*/
 848    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 849    if(BuildServedPlmnret !=ROK)
 850    {
 851       return RFAILED;
 852    }
 853    /*nR Mode Info with FDD*/
 854    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 855    if(BuildNrModeret != ROK)
 856    {
 857       return RFAILED;
 858    }
 859    /*Measurement timing Config*/
 860    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 861       size = sizeof(uint8_t);
 862    DU_ALLOC(srvCellItem->served_Cell_Information.\
 863          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 864    if(srvCellItem->served_Cell_Information.\
 865          measurementTimingConfiguration.buf == NULLP)
 866    {
 867       return RFAILED;
 868    }
 869    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 870                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 871
 872    /* GNB DU System Information */
 873    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 874          sizeof(GNB_DU_System_Information_t));
 875    if(!srvCellItem->gNB_DU_System_Information)
 876    {
 877       return RFAILED;
 878    }
 879    /* MIB */
 880    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
 881    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 882          srvCellItem->gNB_DU_System_Information->mIB_message.size);
 883    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 884    {
 885       return RFAILED;
 886    }
 887    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
 888                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
 889
 890    /* SIB1 */
 891    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 892                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 893
 894    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 895          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 896    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 897    {
 898       return RFAILED;
 899    }
 900    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 901    {
 902       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 903                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 904    }
 905    return ROK;
 906 }
 907 /*******************************************************************
 908  *
 909  * @brief Builds RRC Version
 910  *
 911  * @details
 912  *
 913  *    Function : BuildRrcVer
 914  *
 915  *    Functionality: Building RRC Version
 916  *
 917  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 918  * @return ROK     - success
 919  *         RFAILED - failure
 920  *
 921  * ****************************************************************/
 922 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
 923 {
 924    uint8_t rrcExt;
 925    uint8_t rrcLatest;
 926    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
 927    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
 928    if(rrcVer->latest_RRC_Version.buf == NULLP)
 929    {
 930       return RFAILED;
 931    }
 932    rrcVer->latest_RRC_Version.buf[0] = 0;
 933    rrcVer->latest_RRC_Version.bits_unused = 5;
 934    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 935    if(rrcVer->iE_Extensions == NULLP)
 936    {
 937       return RFAILED;
 938    }
 939    rrcVer->iE_Extensions->list.count = 1;
 940    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
 941    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
 942    if(rrcVer->iE_Extensions->list.array == NULLP)
 943    {
 944       return RFAILED;
 945    }
 946    rrcExt = 0;
 947    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 948          sizeof(RRC_Version_ExtIEs_t));
 949    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 950    {
 951       return RFAILED;
 952    }
 953    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
 954                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 955    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
 956    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
 957                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 958    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 959       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 960    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 961          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 962          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 963    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 964          .Latest_RRC_Version_Enhanced.buf == NULLP)
 965    {
 966       return RFAILED;
 967    }
 968    rrcLatest = 0;
 969    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 970       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
 971    rrcLatest++;
 972    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 973       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
 974    rrcLatest++;
 975    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 976       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
 977    return ROK;
 978 }
 979 /*******************************************************************
 980  *
 981  * @brief Sends F1 msg over SCTP
 982  *
 983  * @details
 984  *
 985  *    Function : sendF1APMsg
 986  *
 987  *    Functionality: Sends F1 msg over SCTP
 988  *
 989  * @params[in] Region region
 990  *             Pool pool
 991  * @return ROK     - success
 992  *         RFAILED - failure
 993  *
 994  * ****************************************************************/
 995 uint8_t sendF1APMsg()
 996 {
 997    Buffer *mBuf = NULLP;
 998
 999    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1000    {
1001       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1002       {
1003             ODU_PRINT_MSG(mBuf, 0,0);
1004
1005             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1006             {
1007                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1008                ODU_PUT_MSG_BUF(mBuf);
1009                return RFAILED;
1010             }
1011       }
1012       else
1013       {
1014          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1015          ODU_PUT_MSG_BUF(mBuf);
1016          return RFAILED;
1017       }
1018       ODU_PUT_MSG_BUF(mBuf);
1019    }
1020    else
1021    {
1022       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1023       return RFAILED;
1024    }
1025    return ROK;
1026 } /* sendF1APMsg */
1027
1028 /*******************************************************************
1029  *
1030  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1031  *
1032  * @details
1033  *
1034  *    Function :  FreeRrcVer
1035  *
1036  *    Functionality: deallocating the memory of function BuildRrcVer
1037  *
1038  * @params[in] RRC_Version_t *rrcVer
1039  *
1040  * @return void
1041  *
1042  *****************************************************************/
1043 void FreeRrcVer(RRC_Version_t *rrcVer)
1044 {
1045    if(rrcVer->latest_RRC_Version.buf != NULLP)
1046    {
1047       if(rrcVer->iE_Extensions != NULLP)
1048       {
1049          if(rrcVer->iE_Extensions->list.array != NULLP)
1050          {
1051             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1052             {
1053                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1054                      != NULLP)
1055                {
1056                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1057                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1058                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1059                }
1060                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1061             }
1062             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1063          }
1064          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1065       }
1066       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1067    }
1068 }
1069
1070 /*******************************************************************
1071  *
1072  * @brief Deallocating memory of TDD NrFreqInfo
1073  *
1074  * @details
1075  *
1076  *    Function : freeTddNrFreqInfo
1077  *
1078  *    Functionality: freeTddNrFreqInfo
1079  *
1080  * @params[in]  F1AP_PDU_t *f1apDuCfg
1081  *
1082  * @return ROK     - void
1083  *
1084  * ****************************************************************/
1085 void freeTddNrFreqInfo(NRFreqInfo_t *freqInfo)
1086 {
1087    uint8_t freqBandListIdx = 0, supportedBandIdx = 0;
1088
1089    if(freqInfo->freqBandListNr.list.array)
1090    {
1091       for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
1092       {
1093          if(freqInfo->freqBandListNr.list.array[freqBandListIdx])
1094          {
1095             if(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
1096             {
1097                for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
1098                {
1099                   DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1100                         sizeof(SupportedSULFreqBandItem_t));
1101                }
1102                DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
1103                      freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
1104
1105             }
1106             DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
1107          }
1108       }
1109       DU_FREE(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
1110    }
1111 }
1112
1113 /*******************************************************************
1114  *
1115  * @brief Deallocating memory allocated for Nr fdd frequencey mode
1116  *
1117  * @details
1118  *
1119  *    Function : freeFddNrFreqInfo
1120  *
1121  *    Functionality:Free memory allocated for Nr fdd frequencey mode
1122  *
1123  * @params[in]
1124  *
1125  * @return ROK     - void
1126  *
1127  * ****************************************************************/
1128 void freeFddNrFreqInfo(FDD_Info_t *fDD)
1129 {
1130    uint8_t arrIdx =0;
1131
1132    if(fDD != NULLP)
1133    {
1134       if(fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1135       {
1136          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1137                array[arrIdx], sizeof(FreqBandNrItem_t));
1138          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1139                fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1140       }
1141
1142       if(fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1143       {
1144          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.\
1145                array[arrIdx], sizeof(FreqBandNrItem_t));
1146          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1147                fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1148       }
1149       DU_FREE(fDD,sizeof(FDD_Info_t));
1150    }
1151 }
1152
1153 /*******************************************************************
1154  *
1155  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1156  *
1157  * @details
1158  *
1159  *    Function :  FreeServedCellList
1160  *
1161  *    Functionality:  deallocating the memory of function BuildServedCellList
1162
1163  *
1164  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1165  *
1166  * @return void
1167  *
1168  * ****************************************************************/
1169 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1170 {
1171    uint8_t   plmnCnt=MAX_PLMN;
1172    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1173    uint8_t  plmnIdx=0, sliceIdx=0;
1174    GNB_DU_Served_Cells_Item_t *srvCellItem;
1175    ServedPLMNs_Item_t  *servedPlmnItem;
1176    SliceSupportItem_t  *sliceSupportItem;
1177
1178    if(duServedCell->list.array!=NULLP)
1179    {
1180       if(duServedCell->list.array[0]!=NULLP)
1181       {
1182          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1183
1184          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1185                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1186          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1187                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1188
1189          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1190          {
1191             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1192                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1193             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1194          }
1195
1196          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1197          {
1198             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1199             {
1200                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1201                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1202
1203                if(servedPlmnItem->iE_Extensions != NULLP)
1204                {
1205                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1206                   {
1207                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1208                      {
1209                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1210                               SliceSupportList.list.array != NULLP)
1211                         {
1212                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1213                                  extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1214                            {
1215                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1216                                     SliceSupportList.list.array[sliceIdx] != NULLP)
1217                               {
1218                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1219                                                     extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1220
1221                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1222
1223                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1224                                  {
1225                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1226                                           sliceSupportItem->sNSSAI.sD->size);
1227                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1228                                  }
1229
1230                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1231                                        choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1232                               }
1233                            }
1234                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1235                                  SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1236                                  extensionValue.choice.SliceSupportList.list.size);
1237                         }
1238                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1239                               sizeof(ServedPLMNs_ItemExtIEs_t));
1240                      }
1241                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1242                            extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1243                   }
1244                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1245                }
1246                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1247                      sizeof(ServedPLMNs_Item_t));
1248             }
1249             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1250                   sizeof(ServedPLMNs_Item_t *));
1251          }
1252
1253          if(srvCellItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1254          {
1255             freeFddNrFreqInfo(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1256          }
1257          else
1258          {
1259             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD != NULLP)
1260             {
1261                freeTddNrFreqInfo(&srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1262                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1263             }
1264          }
1265
1266          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1267                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1268
1269          if(srvCellItem->gNB_DU_System_Information != NULLP)
1270          {
1271             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1272             {
1273                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1274                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1275             }
1276
1277             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1278             {
1279                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1280                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1281             }
1282
1283             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1284          }
1285
1286          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1287       }
1288       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1289    }
1290 }
1291
1292 /*******************************************************************
1293  *
1294  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1295  *
1296  * @details
1297  *
1298  *    Function :  FreeF1SetupReq
1299  *
1300  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1301  *
1302  * @params[in] F1AP_PDU_t *f1apMsg
1303  *
1304  * @return void
1305  *
1306  * ****************************************************************/
1307 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1308 {
1309    uint8_t ieIdx, ieIdx2;
1310    F1SetupRequest_t *f1SetupReq=NULLP;
1311
1312    if(f1apMsg != NULLP)
1313    {
1314       if(f1apMsg->choice.initiatingMessage != NULLP)
1315       {
1316          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1317          if(f1SetupReq->protocolIEs.list.array != NULLP)
1318          {
1319             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1320             {
1321                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1322                {
1323                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1324                   {
1325                      case ProtocolIE_ID_id_TransactionID:
1326                         break;
1327                      case ProtocolIE_ID_id_gNB_DU_ID:
1328                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1329                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1330                         break;
1331                      case ProtocolIE_ID_id_gNB_DU_Name:
1332                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1333                               strlen((char *)duCfgParam.duName));
1334                         break;
1335                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1336                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1337                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1338                         break;
1339                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1340                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1341                         break;
1342                      default:
1343                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1344                         break;
1345                   }
1346                }
1347             }
1348             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1349             {
1350                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1351             }
1352             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1353                   f1SetupReq->protocolIEs.list.size);
1354          }
1355          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1356       }
1357       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1358    }
1359 }
1360 /*******************************************************************
1361  *
1362  * @brief Builds and Send the F1SetupRequest
1363  *
1364  * @details
1365  *
1366  *    Function : BuildAndSendF1SetupReq
1367  *
1368  * Functionality:Fills the F1SetupRequest
1369  *
1370  * @return ROK     - success
1371  *         RFAILED - failure
1372  *
1373  ******************************************************************/
1374 uint8_t BuildAndSendF1SetupReq()
1375 {
1376    uint8_t   ret, ieIdx, elementCnt;
1377    F1AP_PDU_t                 *f1apMsg = NULLP;
1378    F1SetupRequest_t           *f1SetupReq=NULLP;
1379    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1380    RRC_Version_t              *rrcVer=NULLP;
1381    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1382    ret= RFAILED;
1383
1384    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1385    do
1386    {
1387       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1388       if(f1apMsg == NULLP)
1389       {
1390          break;
1391       }
1392       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1393       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1394       if(f1apMsg->choice.initiatingMessage == NULLP)
1395       {
1396          break;
1397       }
1398       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1399       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1400       f1apMsg->choice.initiatingMessage->value.present = \
1401                                                          InitiatingMessage__value_PR_F1SetupRequest;
1402
1403       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1404
1405       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1406
1407       f1SetupReq->protocolIEs.list.count = elementCnt;
1408       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1409
1410       /* Initialize the F1Setup members */
1411       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1412       if(f1SetupReq->protocolIEs.list.array == NULLP)
1413       {
1414          break;
1415       }
1416       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1417       {
1418          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1419                sizeof(F1SetupRequestIEs_t));
1420          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1421          {
1422             break;
1423          }
1424       }
1425
1426       ieIdx = 0;
1427       /*TransactionID*/
1428       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1429       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1430       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1431                                                                F1SetupRequestIEs__value_PR_TransactionID;
1432       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1433                                                                              TRANS_ID;
1434
1435       /*DU ID*/
1436       ieIdx++;
1437       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1438       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1439       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1440                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1441       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1442                                                                              sizeof(uint8_t);
1443
1444       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1445             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1446       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1447             NULLP)
1448       {
1449          break;
1450       }
1451
1452       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1453          duCfgParam.duId;
1454
1455       /*DU Name*/
1456       if(duCfgParam.duName != NULL)
1457       {
1458          ieIdx++;
1459          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1460          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1461          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1462          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1463             strlen((char *)duCfgParam.duName);
1464          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1465                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1466          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1467                buf == NULLP)
1468          {
1469             break;
1470          }
1471          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1472                choice.GNB_DU_Name.buf,
1473                (char*)&duCfgParam.duName);
1474
1475       }
1476
1477       /*Served Cell list */
1478       ieIdx++;
1479       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1480                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1481       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1482       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1483                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1484       duServedCell = &f1SetupReq->protocolIEs.list.\
1485                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1486       if(BuildServedCellList(duServedCell))
1487       {
1488          break;
1489       }
1490       /*RRC Version*/
1491       ieIdx++;
1492       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1493                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1494       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1495       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1496                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1497       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1498       if(BuildRrcVer(rrcVer))
1499       {
1500          break;
1501       }
1502       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1503
1504       /* Encode the F1SetupRequest type as APER */
1505       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1506       encBufSize = 0;
1507       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1508             encBuf);
1509
1510       /* Encode results */
1511       if(encRetVal.encoded == ENCODE_FAIL)
1512       {
1513          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1514                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1515          break;
1516       }
1517       else
1518       {
1519          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1520          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1521          {
1522             printf("%x",encBuf[ieIdx]);
1523          }
1524
1525          duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize;
1526          DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize);
1527          if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
1528          {
1529              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the encoding of f1setup req");
1530              return RFAILED;
1531          }
1532          memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
1533       }
1534
1535       /* Sending msg */
1536       if(sendF1APMsg() != ROK)
1537       {
1538          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1539          break;
1540       }
1541
1542       ret=ROK;
1543       break;
1544    }while(true);
1545
1546    FreeF1SetupReq(f1apMsg);
1547
1548    return ret;
1549 }/* End of BuildAndSendF1SetupReq */
1550
1551 /*******************************************************************
1552  *
1553  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1554  *
1555  * @details
1556  *
1557  *    Function : freeCellsToModifyItem
1558  *
1559  *    Functionality: Deallocating memory of variables allocated in
1560  *                    BuildAndSendDUConfigUpdate function
1561  *
1562  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1563  *
1564  * @return ROK     - void
1565  *
1566  * ****************************************************************/
1567
1568 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1569 {
1570    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1571    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1572    SliceSupportItem_t *sliceSupportItem = NULLP;
1573
1574    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1575    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1576
1577    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1578            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1579    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1580          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1581
1582    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1583    {
1584       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1585       {
1586          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1587
1588          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1589
1590          if(servedPlmnItem->iE_Extensions != NULLP)
1591          {
1592             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1593             {
1594                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1595                {
1596                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1597                         list.array != NULLP)
1598                   {
1599                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1600                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1601                      {
1602                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1603                               list.array[sliceLstIdx] != NULLP)
1604                         {
1605
1606                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1607                                               SliceSupportList.list.array[sliceLstIdx];
1608
1609                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1610                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1611                            {
1612                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1613                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1614                            }
1615                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1616                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1617                         }
1618                      }
1619                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1620                            choice.SliceSupportList.list.array,\
1621                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1622                            extensionValue.choice.SliceSupportList.list.size);
1623                   }
1624                }
1625                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1626                {
1627                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1628                }
1629                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1630             }
1631             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1632          }
1633       }
1634       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1635       {
1636          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1637       }
1638       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1639          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1640    }
1641
1642    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1643    {
1644       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1645    }
1646    else
1647    {
1648       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
1649       {
1650          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1651          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1652       }
1653    }
1654    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1655       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1656 }
1657
1658 /*******************************************************************
1659  *
1660  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1661  *
1662  * @details
1663  *
1664  *    Function : FreeDUConfigUpdate
1665  *
1666  *    Functionality: Deallocating memory of variables allocated in
1667  *                    BuildAndSendDUConfigUpdate function
1668  *
1669  * @params[in]  F1AP_PDU_t *f1apDuCfg
1670  *
1671  * @return ROK     - void
1672  *
1673  * ****************************************************************/
1674 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1675 {
1676    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1677    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1678    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1679    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1680    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1681    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1682
1683    if(f1apDuCfg != NULLP)
1684    {
1685       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1686       {
1687          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1688                        value.choice.GNBDUConfigurationUpdate;
1689          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1690          {
1691             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1692             {
1693                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1694                {
1695                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1696                   {
1697                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1698                         {
1699                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1700                                            value.choice.Served_Cells_To_Modify_List;
1701                            if(cellsToModify->list.array != NULLP)
1702                            {
1703                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1704                               {
1705                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1706                                  {
1707                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1708                                           Served_Cells_To_Modify_Item);
1709                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1710                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1711                                  }
1712                               }
1713                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1714                            }
1715                            break;
1716                         }
1717                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1718                         {
1719                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1720                                            value.choice.Served_Cells_To_Delete_List;
1721                            if(cellsToDelete->list.array != NULLP)
1722                            {
1723                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1724                               {
1725                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1726                                  {
1727                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1728                                           cellsToDelete->list.array[cellDeleteIdx]);
1729                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1730                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1731                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1732                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1733                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1734                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1735                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1736                                  }
1737                               }
1738                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1739                            }
1740
1741                            break;
1742                         }
1743                      case ProtocolIE_ID_id_gNB_DU_ID:
1744                         {
1745                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1746                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1747                            break;
1748                         }
1749                   }
1750                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1751                         sizeof(GNBDUConfigurationUpdateIEs_t));
1752                }
1753             }
1754             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1755          }
1756          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1757       }
1758       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1759    }
1760 }
1761
1762 /*******************************************************************
1763  *
1764  * @brief Fills Served Plmns required in ServCellInfo IE
1765  *
1766  * @details
1767  *
1768  *    Function : fillServedPlmns
1769  *
1770  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1771  *
1772  * @params[in] Pointer to ServedPLMNs_List_t *
1773  *
1774  * @return ROK     - success
1775  *         RFAILED - failure
1776  *
1777  *****************************************************************/
1778
1779 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1780 {
1781    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
1782
1783    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
1784    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
1785          array[arrayIdx]->pLMN_Identity.size);
1786    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
1787    {
1788       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1789       return RFAILED;
1790    }
1791    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
1792          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
1793    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1794    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
1795    {
1796       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1797       return RFAILED;
1798    }
1799
1800    ieListCnt=1;
1801    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
1802    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1803    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
1804          iE_Extensions->list.size);
1805    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
1806    {
1807       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1808       return RFAILED;
1809    }
1810    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
1811    {
1812       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
1813             sizeof(ServedPLMNs_ItemExtIEs_t));
1814       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
1815       {
1816          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1817          return RFAILED;
1818       }
1819    }
1820
1821    ieIdx = 0;
1822    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1823    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
1824    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
1825    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
1826    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1827    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1828       list.count = elementCnt;
1829    servedPlmn->list.array[arrayIdx]->\
1830       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1831       list.size = elementCnt * sizeof(SliceSupportItem_t *);
1832    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1833          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1834          list.array,servedPlmn->list.array[arrayIdx]->\
1835          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
1836    if(servedPlmn->list.array[arrayIdx]->\
1837          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1838          list.array == NULLP)
1839    {
1840       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1841       return RFAILED;
1842    }
1843
1844    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
1845    {
1846       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1847       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1848       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
1849       if(servedPlmn->list.array[arrayIdx]->\
1850       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1851       list.array[sliceLstIdx] == NULLP)
1852       {
1853          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1854          return RFAILED;
1855       }
1856
1857       servedPlmn->list.array[arrayIdx]->\
1858       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1859       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1860       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1861       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1862       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
1863       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
1864       sNSSAI.sST.size);
1865
1866       if(servedPlmn->list.array[arrayIdx]->\
1867       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1868       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1869       {
1870          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1871          return RFAILED;
1872       }
1873       servedPlmn->list.array[arrayIdx]->\
1874       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1875       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1876       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1877
1878       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1879       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1880       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1881       if(servedPlmn->list.array[arrayIdx]->\
1882       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1883       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1884       {
1885          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1886          return RFAILED;
1887       }
1888       servedPlmn->list.array[arrayIdx]->\
1889       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1890       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1891       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1892       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1893       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
1894       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1895       list.array[sliceLstIdx]->sNSSAI.sD->size);
1896       if(servedPlmn->list.array[arrayIdx]->\
1897       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1898       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1899       {
1900          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1901          return RFAILED;
1902       }
1903       memcpy(servedPlmn->list.array[arrayIdx]->\
1904       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1905       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1906       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
1907       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1908       list.array[sliceLstIdx]->sNSSAI.sD->size);
1909    }
1910    return ROK;
1911 }
1912
1913 /*******************************************************************
1914  *
1915  * @brief Fills Nr Fdd Info required in ServCellInfo IE
1916  *
1917  * @details
1918  *
1919  *    Function : fillNrFddInfo
1920  *
1921  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
1922  *
1923  * @params[in] FDD_Info_t *fDD
1924  *
1925  * @return ROK     - success
1926  *         RFAILED - failure
1927  *
1928  *****************************************************************/
1929
1930 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
1931 {
1932    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1933       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1934    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
1935    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1936    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1937          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1938    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1939    {
1940       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1941       return RFAILED;
1942    }
1943
1944    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
1945       sizeof(FreqBandNrItem_t));
1946    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1947    {
1948       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1949       return RFAILED;
1950    }
1951
1952    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1953       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
1954       freqBand[0].nrFreqBand;
1955    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1956    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
1957       dlNrFreqInfo.nrArfcn;
1958    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
1959    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
1960    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1961    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1962    {
1963       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1964       return RFAILED;
1965    }
1966
1967    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
1968    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1969    {
1970       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1971       return RFAILED;
1972    }
1973
1974    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1975       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
1976       freqBand[0].nrFreqBand;
1977    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1978
1979    /*Transmission Bandwidth*/
1980    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1981       f1Mode.mode.fdd.ulTxBw.nrScs;
1982    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1983       f1Mode.mode.fdd.ulTxBw.nrb;
1984    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1985       f1Mode.mode.fdd.dlTxBw.nrScs;
1986    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1987       f1Mode.mode.fdd.dlTxBw.nrb;
1988
1989    return ROK;
1990 }
1991
1992 /*******************************************************************
1993  *
1994  * @brief Fills ServCellInfo IE
1995  *
1996  * @details
1997  *
1998  *    Function : fillServedCellInfo
1999  *
2000  *    Functionality: Fills ServCellInfo
2001  *
2002  * @params[in] Pointer to Served_Cell_Information_t *
2003  *
2004  * @return ROK     - success
2005  *         RFAILED - failure
2006  *
2007  *****************************************************************/
2008
2009 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2010 {
2011    uint8_t ieIdx, ieListCnt;
2012
2013    /*nRCGI*/
2014    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2015    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2016          srvCellInfo->nRCGI.pLMN_Identity.size);
2017    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2018    {
2019       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2020       return RFAILED;
2021    }
2022    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2023          srvCellInfo->nRCGI.pLMN_Identity.buf);
2024    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2025    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2026          srvCellInfo->nRCGI.nRCellIdentity.size);
2027    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2028    {
2029       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2030       return RFAILED;
2031    }
2032
2033    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2034    /*nRPCI*/
2035    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2036
2037    /*servedPLMNs*/
2038    ieListCnt = 1;
2039    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2040    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2041    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2042    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2043    {
2044       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2045       return RFAILED;
2046    }
2047    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2048    {
2049       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2050       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2051       {
2052          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2053          return RFAILED;
2054       }
2055    }
2056    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2057    {
2058       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2059       return RFAILED;
2060    }
2061
2062 #ifndef NR_TDD
2063    /*nR Mode Info with FDD*/
2064    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2065    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2066    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2067    {
2068       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2069       return RFAILED;
2070    }
2071    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2072    {
2073        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2074       return RFAILED;
2075    }
2076 #else
2077    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2078    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2079    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2080    {
2081       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2082       return RFAILED;
2083    }
2084    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2085    {
2086       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2087       return RFAILED;
2088    }
2089 #endif
2090
2091    /*Measurement timing Config*/
2092    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2093    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2094          buf,srvCellInfo->measurementTimingConfiguration.size);
2095    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2096    {
2097       return RFAILED;
2098    }
2099    srvCellInfo->measurementTimingConfiguration.\
2100          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2101
2102    return ROK;
2103 }
2104
2105 /*******************************************************************
2106  *
2107  * @brief Fills ServCellToModItem IE
2108  *
2109  * @details
2110  *
2111  *    Function : fillServCellToModItem
2112  *
2113  *    Functionality: Fills ServCellToModItem IE
2114  *
2115  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2116  *
2117  * @return ROK     - success
2118  *         RFAILED - failure
2119  *
2120  *****************************************************************/
2121
2122 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2123 {
2124    /*pLMN_Identity*/
2125    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2126    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2127    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2128    {
2129       return RFAILED;
2130    }
2131    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2132          modifyItem->oldNRCGI.pLMN_Identity.buf);
2133
2134    /*nRCellIdentity*/
2135    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2136    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2137          modifyItem->oldNRCGI.nRCellIdentity.size);
2138    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2139    {
2140       return RFAILED;
2141    }
2142    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2143
2144    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2145       return RFAILED;
2146    else
2147       return ROK;
2148 }
2149
2150 /*******************************************************************
2151  *
2152  * @brief Builds ServCellToModList
2153  *
2154  * @details
2155  *
2156  *    Function : buildServCellToModList
2157  *
2158  *    Functionality: Builds the serv cell to Mod List
2159  *
2160  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2161  *
2162  * @return ROK     - success
2163  *         RFAILED - failure
2164  *
2165  *****************************************************************/
2166
2167 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2168 {
2169    uint8_t ieListCnt, ieIdx;
2170    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2171
2172    ieListCnt = 1;
2173    cellsToModify->list.count = ieListCnt;
2174    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2175    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2176    if(cellsToModify->list.array == NULLP)
2177    {
2178       return RFAILED;
2179    }
2180    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2181    {
2182       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2183       if(cellsToModify->list.array[ieIdx] == NULLP)
2184       {
2185          return RFAILED;
2186       }
2187    }
2188    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2189    cellsToModify->list.array[0]->criticality = Criticality_reject;
2190    cellsToModify->list.array[0]->value.present =\
2191       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2192    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2193
2194    if(fillServCellToModItem(modifyItem))
2195       return RFAILED;
2196    else
2197       return ROK;
2198 }
2199 /*******************************************************************
2200  *
2201  * @brief filling the DeleteItemList
2202  *
2203  * @details
2204  *
2205  *    Function : fillCellToDeleteItem
2206  *
2207  *    Functionality: Filling the DeleteItemIe
2208  *
2209  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2210  *
2211  * @return ROK     - success
2212  *         RFAILED - failure
2213  *
2214  *****************************************************************/
2215 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2216 {
2217    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2218
2219    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2220    deleteItemIe->criticality = Criticality_reject;
2221    deleteItemIe->value.present =\
2222    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2223    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2224
2225    /*pLMN_Identity*/
2226    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2227    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2228    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2229    {
2230       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2231       return RFAILED;
2232    }
2233    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2234          deleteItem->oldNRCGI.pLMN_Identity.buf);
2235
2236    /*nRCellIdentity*/
2237    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2238    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2239          deleteItem->oldNRCGI.nRCellIdentity.size);
2240    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2241    {
2242       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2243       return RFAILED;
2244    }
2245    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2246    return ROK;
2247 }
2248 /*******************************************************************
2249  *
2250  * @brief Builds ServCellToDeleteList
2251  *
2252  * @details
2253  *
2254  *    Function : buildServCellToDeleteList
2255  *
2256  *    Functionality: Builds the serv cell to delete List
2257  *
2258  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2259  *
2260  * @return ROK     - success
2261  *         RFAILED - failure
2262  *
2263  *****************************************************************/
2264
2265 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2266 {
2267    uint8_t ieListCnt, arrIdx;
2268
2269    ieListCnt = 1;
2270    cellsToDelete->list.count = ieListCnt;
2271    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2272
2273    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2274    if(cellsToDelete->list.array == NULLP)
2275    {
2276       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2277       return RFAILED;
2278    }
2279
2280    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2281    {
2282       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2283       if(cellsToDelete->list.array[arrIdx] == NULLP)
2284       {
2285          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2286          return RFAILED;
2287       }
2288    }
2289
2290    arrIdx=0;
2291    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2292    {
2293       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2294       return RFAILED;
2295    }
2296    return ROK;
2297 }
2298
2299 /*******************************************************************
2300  *
2301  * @brief Builds and sends the DUConfigUpdate
2302  *
2303  * @details
2304  *
2305  *    Function : BuildAndSendDUConfigUpdate
2306  *
2307  *    Functionality: Constructs the DU Update message and sends
2308  *                   it to the CU through SCTP.
2309  *
2310  * @params[in] void **buf,Buffer to which encoded pattern is written into
2311  * @params[in] int *size,size of buffer
2312  *
2313  * @return ROK     - success
2314  *         RFAILED - failure
2315  *
2316  * ****************************************************************/
2317 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2318 {
2319    uint8_t ret =0, ieIdx=0, elementCnt=0;
2320    bool memAlloctionFailure = false;
2321    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2322    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2323    asn_enc_rval_t encRetVal;     /* Encoder return value */
2324
2325    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2326    ret= RFAILED;
2327
2328    while(true)
2329    {
2330       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2331       /* Allocate the memory for F1DuCfg */
2332       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2333       if(f1apDuCfg == NULLP)
2334       {
2335          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2336          break;
2337       }
2338
2339       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2340       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2341       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2342       {
2343          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2344          break;
2345       }
2346
2347       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2348                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2349       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2350       f1apDuCfg->choice.initiatingMessage->value.present = \
2351                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2352       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2353                     choice.GNBDUConfigurationUpdate;
2354       elementCnt = 3;
2355       duCfgUpdate->protocolIEs.list.count = elementCnt;
2356       duCfgUpdate->protocolIEs.list.size = \
2357                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2358
2359       /* Initialize the F1Setup members */
2360       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2361       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2362       {
2363          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2364          break;
2365       }
2366       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2367       {
2368          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2369          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2370          {
2371             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2372             memAlloctionFailure = true;
2373             break;
2374          }
2375       }
2376
2377       if(memAlloctionFailure == true)
2378       {
2379          break;
2380       }
2381       /*TransactionID*/
2382       ieIdx = 0;
2383       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2384       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2385       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2386       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2387       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2388
2389       ieIdx++;
2390       if(servCellAction == SERV_CELL_TO_MODIFY)
2391       {
2392          /*Served Cell to Modify */
2393          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2394          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2395          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2396          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2397          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2398          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2399                   Served_Cells_To_Modify_List))
2400          {
2401             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2402             break;
2403          }
2404       }
2405       else
2406       {
2407          /*Served Cell to Delete */
2408          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2409          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2410          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2411          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2412          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2413          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2414          Served_Cells_To_Delete_List)!=ROK)
2415          {
2416             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2417             break;
2418          }
2419
2420       }
2421       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2422       /*GNB DU ID */
2423       ieIdx++;
2424       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2425       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2426       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2427       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2428       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2429       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2430             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2431       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2432       {
2433          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2434          break;
2435       }
2436       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2437
2438       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2439
2440       /* Encode the DU Config Update type as APER */
2441       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2442       encBufSize = 0;
2443       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2444
2445       /* Checking encode results */
2446       if(encRetVal.encoded == ENCODE_FAIL)
2447       {
2448          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2449                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2450          break;
2451       }
2452       else
2453       {
2454          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2455          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2456          {
2457             printf("%x",encBuf[ieIdx]);
2458          }
2459       }
2460       /* Sending msg */
2461       if(sendF1APMsg() != ROK)
2462       {
2463          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2464          break;
2465       }
2466
2467       ret = ROK;
2468       break;
2469    }
2470
2471    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2472    return ret;
2473 }
2474
2475
2476 /*******************************************************************
2477  *
2478  * @brief free the ULRRCMessageTransfer
2479  *
2480  * @details
2481  *
2482  *    Function : FreeULRRCMessageTransfer
2483  *
2484  *    Functionality: Deallocating the memory of variable allocated in
2485  *                      FreeULRRCMessageTransfer
2486  *
2487  * @params[in]
2488  *
2489  * @return ROK     - void
2490  *
2491  ******************************************************************/
2492 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2493 {
2494    uint8_t idx1;
2495    ULRRCMessageTransfer_t  *ulRRCMsg;
2496
2497    if(f1apMsg != NULLP)
2498    {
2499       if(f1apMsg->choice.initiatingMessage != NULLP)
2500       {
2501          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2502          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2503          {
2504             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2505             {
2506                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2507                {
2508                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2509                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2510                   {
2511                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2512                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2513                   }
2514                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2515                }
2516             }
2517             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2518          }
2519          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2520       }
2521       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2522    }
2523 }
2524 /*******************************************************************
2525  *
2526  * @brief Builds and sends the ULRRCMessageTransfer
2527  *
2528  * @details
2529  *
2530  *    Function : BuildAndSendULRRCMessageTransfer
2531  *
2532  *    Functionality: Constructs the UL RRC Message Transfer and sends
2533  *                   it to the CU through SCTP.
2534  *
2535  * @params[in]
2536  *
2537  * @return ROK     - success
2538  *         RFAILED - failure
2539  *
2540  * ****************************************************************/
2541 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2542       uint16_t msgLen, uint8_t *rrcMsg)
2543 {
2544    uint8_t   elementCnt =0;
2545    uint8_t   idx1 =0;
2546    uint8_t   idx =0;
2547    F1AP_PDU_t                   *f1apMsg = NULLP;
2548    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2549    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2550    uint8_t ret =RFAILED;
2551
2552    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2553
2554    while(true)
2555    {
2556       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2557
2558       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2559       if(f1apMsg == NULLP)
2560       {
2561          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2562          break;
2563       }
2564       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2565       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2566       if(f1apMsg->choice.initiatingMessage == NULLP)
2567       {
2568          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2569          break;
2570       }
2571       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2572       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2573       f1apMsg->choice.initiatingMessage->value.present = \
2574                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2575       ulRRCMsg =
2576          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2577       elementCnt = 4;
2578       ulRRCMsg->protocolIEs.list.count = elementCnt;
2579       ulRRCMsg->protocolIEs.list.size = \
2580                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2581
2582       /* Initialize the F1Setup members */
2583       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2584       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2585       {
2586          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2587          break;
2588       }
2589       for(idx=0; idx<elementCnt; idx++)
2590       {
2591          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2592          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2593          {
2594             break;
2595          }
2596       }
2597
2598       idx1 = 0;
2599
2600       /*GNB CU UE F1AP ID*/
2601       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2602       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2603       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2604                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2605       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2606
2607       /*GNB DU UE F1AP ID*/
2608       idx1++;
2609       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2610       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2611       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2612                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2613       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2614
2615       /*SRBID*/
2616       idx1++;
2617       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2618       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2619       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2620                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2621       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2622
2623       /*RRCContainer*/
2624       idx1++;
2625       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2626       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2627       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2628                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2629       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2630       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2631             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2632       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2633       {
2634          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2635          break;
2636       }
2637       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2638       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2639             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2640
2641       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2642
2643       /* Encode the F1SetupRequest type as APER */
2644       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2645       encBufSize = 0;
2646       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2647             encBuf);
2648       /* Encode results */
2649       if(encRetVal.encoded == ENCODE_FAIL)
2650       {
2651          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2652                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2653          break;
2654       }
2655       else
2656       {
2657          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2658          for(int i=0; i< encBufSize; i++)
2659          {
2660             printf("%x",encBuf[i]);
2661          }
2662       }
2663
2664       /* Sending  msg  */
2665       if(sendF1APMsg()  !=      ROK)
2666       {
2667          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2668          break;
2669       }
2670       ret = ROK;
2671       break;
2672    }
2673    FreeULRRCMessageTransfer(f1apMsg);
2674
2675    return ret;
2676 }/* End of BuildAndSendULRRCMessageTransfer*/
2677
2678 /*******************************************************************
2679  *
2680  * @brief Builds tag config
2681  *
2682  * @details
2683  *
2684  *    Function : BuildTagConfig
2685  *
2686  *    Functionality: Builds tag config in MacCellGroupConfig
2687  *
2688  * @params[in] TAG_Config *tag_Config
2689  *
2690  * @return ROK     - success
2691  *         RFAILED - failure
2692  *
2693  * ****************************************************************/
2694 uint8_t BuildTagConfig(DuUeCb *ueCb, struct TAG_Config *tagConfig)
2695 {
2696    struct TAG_Config__tag_ToAddModList *tagList;
2697    uint8_t                     idx, elementCnt;
2698
2699    tagConfig->tag_ToReleaseList = NULLP;
2700    tagConfig->tag_ToAddModList = NULLP;
2701    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2702    if(!tagConfig->tag_ToAddModList)
2703    {
2704       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2705       return RFAILED;
2706    }
2707
2708    if(ueCb == NULLP)
2709       elementCnt = ODU_VALUE_ONE;
2710    else
2711       elementCnt = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModListCount;
2712
2713    tagList = tagConfig->tag_ToAddModList;
2714    tagList->list.count = elementCnt;
2715    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2716
2717    tagList->list.array = NULLP;
2718    DU_ALLOC(tagList->list.array, tagList->list.size);
2719    if(!tagList->list.array)
2720    {
2721       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2722       return RFAILED;
2723    }
2724
2725    for(idx=0; idx<tagList->list.count; idx++)
2726    {
2727       tagList->list.array[idx] = NULLP;
2728       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2729       if(!tagList->list.array[idx])
2730       {
2731          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2732          return RFAILED;
2733       }
2734    }
2735
2736    if(ueCb == NULLP)
2737    {
2738       idx = 0;
2739       tagList->list.array[idx]->tag_Id = TAG_ID;
2740       tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2741    }
2742    else
2743    {
2744       for(idx=0; idx<tagList->list.count; idx++)
2745       {
2746          tagList->list.array[idx]->tag_Id = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].tagId;
2747          tagList->list.array[idx]->timeAlignmentTimer = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].timeAlignTimer;
2748       }
2749    }
2750
2751    return ROK;
2752 }
2753
2754 /*******************************************************************
2755  *
2756  * @brief Builds PHR Config
2757  *
2758  * @details
2759  *
2760  *    Function : BuildPhrConfig
2761  *
2762  *    Functionality: Builds phrConfig in MacCellGroupConfig
2763  *
2764  * @params[in] PHR Config *
2765  *
2766  * @return ROK     - success
2767  *         RFAILED - failure
2768  *
2769  * ****************************************************************/
2770 uint8_t BuildPhrConfig(DuUeCb *ueCb, struct MAC_CellGroupConfig__phr_Config *phrConfig)
2771 {
2772
2773    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2774    phrConfig->choice.setup = NULLP;
2775    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2776    if(!phrConfig->choice.setup)
2777    {
2778       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2779       return RFAILED;
2780    }
2781
2782    if(ueCb == NULLP)
2783    {
2784       phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2785       phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2786       phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2787       phrConfig->choice.setup->multiplePHR              = false;
2788       phrConfig->choice.setup->dummy                    = false;
2789       phrConfig->choice.setup->phr_Type2OtherCell       = false;
2790       phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2791    }
2792    else
2793    {
2794       phrConfig->choice.setup->phr_PeriodicTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.periodicTimer;
2795       phrConfig->choice.setup->phr_ProhibitTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.prohibitTimer;
2796       phrConfig->choice.setup->phr_Tx_PowerFactorChange = ueCb->macUeCfg.macCellGrpCfg.phrCfg.txPowerFactor;
2797       phrConfig->choice.setup->multiplePHR              = ueCb->macUeCfg.macCellGrpCfg.phrCfg.multiplePHR;
2798       phrConfig->choice.setup->dummy                    = ueCb->macUeCfg.macCellGrpCfg.phrCfg.dummy;
2799       phrConfig->choice.setup->phr_Type2OtherCell       = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrType2OtherCell;
2800       phrConfig->choice.setup->phr_ModeOtherCG          = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrOtherCG;
2801    }
2802
2803    return ROK;
2804 }
2805
2806 /*******************************************************************
2807  *
2808  * @brief Builds BSR Config
2809  *
2810  * @details
2811  *
2812  *    Function : BuildBsrConfig
2813  *
2814  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2815  *
2816  * @params[in] BSR_Config *bsrConfig
2817  *
2818  * @return ROK     - success
2819  *         RFAILED - failure
2820  *
2821  * ****************************************************************/
2822 uint8_t BuildBsrConfig(DuUeCb *ueCb, struct BSR_Config *bsrConfig)
2823 {
2824    if(ueCb == NULLP)
2825    {
2826       bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2827       bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2828       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2829    }
2830    else
2831    {
2832       bsrConfig->periodicBSR_Timer = convertBsrPeriodicTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.periodicTimer);
2833       bsrConfig->retxBSR_Timer     = convertBsrRetxTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.retxTimer);
2834
2835       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2836       DU_ALLOC(bsrConfig->logicalChannelSR_DelayTimer, sizeof(long));
2837       if(bsrConfig->logicalChannelSR_DelayTimer == NULLP)
2838       {
2839          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildBsrConfig");
2840          return RFAILED;
2841       }
2842       *(bsrConfig->logicalChannelSR_DelayTimer) = convertLcSrDelayTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.srDelayTimer);
2843    }
2844
2845    return ROK;
2846 }
2847
2848 /*******************************************************************
2849  *
2850  * @brief Builds scheduling request config
2851  *
2852  * @details
2853  *
2854  *    Function : BuildSchedulingReqConfig
2855  *
2856  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2857  *
2858  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2859  *
2860  * @return ROK     - success
2861  *         RFAILED - failure
2862  *
2863  * ****************************************************************/
2864 uint8_t BuildSchedulingReqConfig(DuUeCb *ueCb, struct SchedulingRequestConfig *schedulingRequestConfig)
2865 {
2866    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2867    uint8_t                     idx, elementCnt;
2868
2869    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2870    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2871          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2872    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2873    {
2874       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2875       return RFAILED;
2876    }
2877
2878    if(ueCb == NULLP)
2879       elementCnt = ODU_VALUE_ONE;
2880    else
2881       elementCnt = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModListCount;
2882
2883    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2884    schReqList->list.count = elementCnt;
2885    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2886
2887    schReqList->list.array = NULLP;
2888    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2889    if(!schReqList->list.array)
2890    {
2891       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2892       return RFAILED;
2893    }
2894
2895    for(idx=0; idx<schReqList->list.count; idx++)
2896    {
2897       schReqList->list.array[idx] = NULLP;
2898       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2899       if(!schReqList->list.array[idx])
2900       {
2901          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2902          return RFAILED;
2903       }
2904    }
2905
2906    if(ueCb == NULLP)
2907    {
2908       idx = 0;
2909       schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2910
2911       schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2912       DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2913       if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2914       {
2915          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2916          return RFAILED;
2917       }
2918       *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2919       schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2920    }
2921    else
2922    {
2923       for(idx=0; idx<schReqList->list.count; idx++)
2924       {
2925          schReqList->list.array[idx]->schedulingRequestId = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].schedReqId;
2926
2927          schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2928          DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2929          if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2930          {
2931             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2932             return RFAILED;
2933          }
2934          *(schReqList->list.array[idx]->sr_ProhibitTimer) = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srProhibitTmr;
2935          schReqList->list.array[idx]->sr_TransMax = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srTransMax;
2936       }
2937    }
2938
2939    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2940
2941    return ROK;
2942 }
2943
2944 /*******************************************************************
2945  *
2946  * @brief Builds RLC Configuration for AM mode
2947  *
2948  * @details
2949  *
2950  *    Function : BuildRlcConfigAm
2951  *
2952  *    Functionality:
2953  *       Builds AM mode RLC Config in BuildRlcBearerToAddModList
2954  *
2955  * @params[in] AmBearerCfg *amCfg
2956  *             RLC_Config_t  *rlcConfig
2957  *
2958  * @return ROK     - success
2959  *         RFAILED - failure
2960  *
2961  * ****************************************************************/
2962 uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig)
2963 {
2964    rlcConfig->choice.am = NULLP;
2965    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2966    if(!rlcConfig->choice.am)
2967    {
2968       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
2969       return RFAILED;
2970    }
2971
2972    /* Fill AM UL configuration */
2973    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2974    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2975    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2976    {
2977       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
2978       return RFAILED;
2979    }
2980
2981    /* Fill default AM UL configuration if input pointer to DU database is NULL */
2982    if(amCfg == NULLP)
2983    {
2984       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2985       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2986       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2987       rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2988       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2989    }
2990    else
2991    {
2992       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->dlAmCfg.snLenDl);
2993       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = covertPollRetxTmrValueToEnum(amCfg->dlAmCfg.pollRetxTmr);
2994       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = covertPollPduValueToEnum(amCfg->dlAmCfg.pollPdu);
2995       rlcConfig->choice.am->ul_AM_RLC.pollByte          = covertPollByteValueToEnum(amCfg->dlAmCfg.pollByte);
2996       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = covertMaxRetxValueToEnum(amCfg->dlAmCfg.maxRetxTh);
2997    }
2998
2999    /* Fill AM DL configuraion */
3000    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3001    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3002    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3003    {
3004       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3005       return RFAILED;
3006    }
3007
3008    /* Fill default AM DL configuration if input pointer to DU database is NULL */
3009    if(amCfg == NULLP)
3010    {
3011       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3012       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3013       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3014    }
3015    else /* Fill AM configuration from DU database */
3016    {
3017       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->ulAmCfg.snLenUl);
3018       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = convertReasmblTmrValueToEnum(amCfg->ulAmCfg.reAssemTmr);
3019       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = convertProhibitTmrValueToEnum(amCfg->ulAmCfg.statProhTmr);
3020    }
3021    return ROK;
3022 }
3023
3024 /*******************************************************************
3025  *
3026  * @brief Builds RLC Config for UM Bidirection
3027  *
3028  * @details
3029  *
3030  *    Function : BuildRlcConfig UmBiDir
3031  *
3032  *    Functionality:
3033  *       Builds RLC Config for UM Bidirection in BuildRlcBearerToAddModList
3034  *
3035  * @params[in] UmBiDirBearerCfg *umBiDirCfg
3036  *             RLC_Config_t *rlcConfig
3037  *
3038  * @return ROK     - success
3039  *         RFAILED - failure
3040  *
3041  * ****************************************************************/
3042 uint8_t BuildRlcConfigUmBiDir(UmBiDirBearerCfg *umBiDirCfg, struct RLC_Config *rlcConfig)
3043 {
3044    rlcConfig->choice.um_Bi_Directional = NULLP;
3045    DU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
3046    if(rlcConfig->choice.um_Bi_Directional == NULLP)
3047    {
3048       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3049       return RFAILED;
3050    }
3051
3052    /* Fill UM Bidirectional UL configuration */
3053    rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
3054    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3055    if(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength == NULLP)
3056    {
3057       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3058       return RFAILED;
3059    }
3060
3061    if(umBiDirCfg != NULLP)
3062    {
3063       *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->dlUmCfg.snLenDlUm);
3064    }
3065
3066    /* Fill UM Bidirectional DL configuration */
3067    rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
3068    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3069    if(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength == NULLP)
3070    {
3071       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3072       return RFAILED;
3073    }
3074
3075    if(umBiDirCfg != NULLP)
3076    {
3077       *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->ulUmCfg.snLenUlUm);
3078       rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umBiDirCfg->ulUmCfg.reAssemTmr);
3079    }
3080
3081    return ROK;
3082 }
3083
3084 /*******************************************************************
3085  *
3086  * @brief Builds RLC Config for UM Uni directional UL
3087  *
3088  * @details
3089  *
3090  *    Function : BuildRlcConfigUmUniDirUl
3091  *
3092  *    Functionality:
3093  *       Builds RLC Config for UM Unidirection UL in BuildRlcBearerToAddModList
3094  *
3095  * @params[in] UmUniDirDlBearerCfg *umUniDirDlCfg
3096  *             RLC_Config_t *rlcConfig
3097  *
3098  * @return ROK     - success
3099  *         RFAILED - failure
3100  *
3101  * ****************************************************************/
3102 uint8_t BuildRlcConfigUmUniDirUl(UmUniDirDlBearerCfg *umUniDirDlCfg, RLC_Config_t *rlcConfig)
3103 {
3104    rlcConfig->choice.um_Uni_Directional_UL = NULLP;
3105    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
3106    if(rlcConfig->choice.um_Uni_Directional_UL == NULLP)
3107    {
3108       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3109       return RFAILED;
3110    }
3111
3112    rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength = NULLP;
3113    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3114    if(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength == NULLP)
3115    {
3116       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3117       return RFAILED;
3118    }
3119
3120    if(umUniDirDlCfg != NULLP)
3121    {
3122       *(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirDlCfg->dlUmCfg.snLenDlUm);
3123    }
3124
3125    return ROK;
3126 }
3127
3128 /*******************************************************************
3129  *
3130  * @brief Builds RLC Config for UM Uni directional DL
3131  *
3132  * @details
3133  *
3134  *    Function : BuildRlcConfigUmUniDirDl
3135  *
3136  *    Functionality:
3137  *       Builds RLC Config for UM Unidirection DL in BuildRlcBearerToAddModList
3138  *
3139  * @params[in] UmUniDirUlBearerCfg *umUniDirUlCfg
3140  *             RLC_Config_t *rlcConfig
3141  *
3142  * @return ROK     - success
3143  *         RFAILED - failure
3144  *
3145  * ****************************************************************/
3146 uint8_t BuildRlcConfigUmUniDirDl(UmUniDirUlBearerCfg *umUniDirUlCfg, RLC_Config_t *rlcConfig)
3147 {
3148    rlcConfig->choice.um_Uni_Directional_DL = NULLP;
3149    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
3150    if(rlcConfig->choice.um_Uni_Directional_DL == NULLP)
3151    {
3152       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3153       return RFAILED;
3154    }
3155
3156    rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength = NULLP;
3157    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3158    if(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength == NULLP)
3159    {
3160       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3161       return RFAILED;
3162    }
3163
3164    if(umUniDirUlCfg != NULLP)
3165    {
3166       *(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirUlCfg->ulUmCfg.snLenUlUm);
3167       rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umUniDirUlCfg->ulUmCfg.reAssemTmr);
3168    }
3169
3170    return ROK;
3171 }
3172
3173 /*******************************************************************
3174  *
3175  * @brief Builds RLC Config
3176  *
3177  * @details
3178  *
3179  *    Function : BuildRlcConfig
3180  *
3181  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3182  *
3183  * @params[in] RLC_Config_t *rlcConfig
3184  *
3185  * @return ROK     - success
3186  *         RFAILED - failure
3187  *
3188  * ****************************************************************/
3189 uint8_t BuildRlcConfig(RlcBearerCfg *rbCfg, struct RLC_Config *rlcConfig)
3190 {
3191
3192    /* Fill default values if rbCfg is NULL */
3193    if(rbCfg == NULLP)
3194    {
3195       rlcConfig->present = RLC_Config_PR_am;
3196       BuildRlcConfigAm(NULLP, rlcConfig);
3197    }
3198    /* If RbCfg is present, fill RLC configurations from DU Database */
3199    else
3200    {
3201       rlcConfig->present = covertRlcModeFromIntEnumToRrcEnum(rbCfg->rlcMode);
3202       switch(rlcConfig->present)
3203       {
3204          case RLC_Config_PR_am:
3205             BuildRlcConfigAm(rbCfg->u.amCfg, rlcConfig);
3206             break;
3207          case RLC_Config_PR_um_Bi_Directional:
3208             BuildRlcConfigUmBiDir(rbCfg->u.umBiDirCfg, rlcConfig);
3209             break;
3210          case RLC_Config_PR_um_Uni_Directional_UL:
3211             BuildRlcConfigUmUniDirUl(rbCfg->u.umUniDirDlCfg, rlcConfig);
3212             break;
3213          case RLC_Config_PR_um_Uni_Directional_DL:
3214             BuildRlcConfigUmUniDirDl(rbCfg->u.umUniDirUlCfg, rlcConfig);
3215             break;
3216          case RLC_Config_PR_NOTHING:
3217          default:
3218             break;
3219       }
3220    }
3221
3222    return ROK;
3223 }
3224
3225 /*******************************************************************
3226  *
3227  * @brief Builds MAC LC Config
3228  *
3229  * @details
3230  *
3231  *    Function : BuildMacLCConfig
3232  *
3233  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3234  *
3235  * @params[in] struct LogicalChannelConfig macLcConfig
3236  *
3237  * @return ROK     - success
3238  *         RFAILED - failure
3239  *
3240  * ****************************************************************/
3241 uint8_t BuildMacLCConfig(LcCfg *lcCfgDb, struct LogicalChannelConfig *macLcConfig)
3242 {
3243    macLcConfig->ul_SpecificParameters = NULLP;
3244    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3245    if(!macLcConfig->ul_SpecificParameters)
3246    {
3247       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3248       return RFAILED;
3249    }
3250
3251    if(lcCfgDb == NULLP)
3252    {
3253       macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3254       macLcConfig->ul_SpecificParameters->prioritisedBitRate =  PRIORTISIED_BIT_RATE;
3255       macLcConfig->ul_SpecificParameters->bucketSizeDuration =  BUCKET_SIZE_DURATION;
3256    }
3257    else
3258    {
3259       macLcConfig->ul_SpecificParameters->priority = lcCfgDb->ulLcCfg.priority;
3260       macLcConfig->ul_SpecificParameters->prioritisedBitRate = lcCfgDb->ulLcCfg.pbr;
3261       macLcConfig->ul_SpecificParameters->bucketSizeDuration = lcCfgDb->ulLcCfg.bsd;
3262    }
3263
3264    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3265    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3266    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3267    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3268
3269    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3270    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3271    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3272    {
3273       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3274       return RFAILED;
3275    }
3276
3277    if(lcCfgDb == NULLP)
3278       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3279    else
3280       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = lcCfgDb->ulLcCfg.lcGroup;
3281
3282    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3283    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3284    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3285    {
3286       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3287       return RFAILED;
3288    }
3289
3290    if(lcCfgDb == NULLP)
3291       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3292    else
3293       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = lcCfgDb->ulLcCfg.schReqId;
3294
3295    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3296    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3297    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3298
3299    return ROK;
3300 }
3301
3302 /*******************************************************************
3303  *
3304  * @brief Builds RLC Bearer to Add/Mod list
3305  *
3306  * @details
3307  *
3308  *    Function :BuildRlcBearerToAddModList
3309  *
3310  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3311  *
3312  * @params[in] rlc_BearerToAddModList
3313  *
3314  * @return ROK     - success
3315  *         RFAILED - failure
3316  *
3317  * ****************************************************************/
3318 uint8_t BuildRlcBearerToAddModList(DuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3319 {
3320    uint8_t  idx = 0, lcIdx=0, macLcIdx = 0, elementCnt = 0;
3321
3322    if(ueCb == NULLP)
3323       elementCnt = 1;
3324    else if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
3325       elementCnt = ueCb->rlcUeCfg.numLcs;
3326    else
3327    {
3328       for(lcIdx = 0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3329       {
3330          if(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == false)
3331             elementCnt++;
3332       }
3333    }
3334    rlcBearerList->list.count = elementCnt;
3335    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3336
3337    rlcBearerList->list.array = NULLP;
3338    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3339    if(!rlcBearerList->list.array)
3340    {
3341       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3342       return RFAILED;
3343    }
3344
3345    for(idx=0; idx<rlcBearerList->list.count; idx++)
3346    {
3347       rlcBearerList->list.array[idx] = NULLP;
3348       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3349       if(!rlcBearerList->list.array[idx])
3350       {
3351          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3352          return RFAILED;
3353       }
3354    }
3355
3356    if(ueCb == NULLP)
3357    {
3358       idx=0;
3359       rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3360       DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3361       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3362       {
3363          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3364          return RFAILED;
3365       }
3366       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3367       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB1_LCID;
3368       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3369
3370       /* Fill RLC related Configurations for this Radio Bearer */
3371       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3372       DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3373       if(!rlcBearerList->list.array[idx]->rlc_Config)
3374       {
3375          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3376          return RFAILED;
3377       }
3378       if(BuildRlcConfig(NULLP, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3379       {
3380          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3381          return RFAILED;
3382       }
3383
3384       /* Fill MAC related configurations for this Radio Bearer */
3385       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3386       DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3387       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3388       {
3389          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3390          return RFAILED;
3391       }
3392       if(BuildMacLCConfig(NULLP, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3393       {
3394          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3395          return RFAILED;
3396       }
3397    }
3398    else
3399    {
3400       idx=0;
3401       for(lcIdx=0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3402       {
3403          if((ueCb->f1UeDb->actionType != UE_CTXT_CFG_QUERY) && (ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == true))
3404             continue;
3405
3406          /* Fill Logical channel identity */
3407          rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId;
3408
3409          /* Fill Radio Bearer Id and type (DRB/SRB) for this logical channel */
3410          DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3411          if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3412          {
3413             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3414             return RFAILED;
3415          }
3416          rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3417                                                                       covertRbTypeFromIntEnumToRrcEnum(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbType);
3418          switch(rlcBearerList->list.array[idx]->servedRadioBearer->present)
3419          {
3420             case RLC_BearerConfig__servedRadioBearer_PR_srb_Identity:
3421                rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3422                break;
3423             case RLC_BearerConfig__servedRadioBearer_PR_drb_Identity:
3424                rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3425                break;
3426             case RLC_BearerConfig__servedRadioBearer_PR_NOTHING:
3427             default:
3428                break;
3429          }
3430          ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent = true;
3431
3432          rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3433
3434          /* Fill RLC related Configurations for this Radio Bearer */
3435          rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3436          DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3437          if(!rlcBearerList->list.array[idx]->rlc_Config)
3438          {
3439             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3440             return RFAILED;
3441          }
3442          if(BuildRlcConfig(&ueCb->rlcUeCfg.rlcLcCfg[lcIdx], rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3443          {
3444             DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3445             return RFAILED;
3446          }
3447
3448          /* Fill MAC related configurations for this Radio Bearer */
3449          rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3450          DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3451          if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3452          {
3453             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3454             return RFAILED;
3455          }
3456          for(macLcIdx = 0; macLcIdx < ueCb->macUeCfg.numLcs; macLcIdx++)
3457          {
3458             if(ueCb->macUeCfg.lcCfgList[macLcIdx].lcId == ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId)
3459             {
3460                if(BuildMacLCConfig(&ueCb->macUeCfg.lcCfgList[macLcIdx], rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3461                {
3462                   DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3463                   return RFAILED;
3464                }
3465                break;
3466             }
3467          }
3468
3469          idx++;
3470       }
3471    }
3472    return ROK;
3473 }
3474
3475 /*******************************************************************
3476  *
3477  * @brief Build Control resource set to add/modify list
3478  *
3479  * @details
3480  *
3481  *    Function : BuildControlRSetToAddModList
3482  *
3483  *    Functionality: Build Control resource set to add/modify list
3484  *
3485  * @params[in]
3486  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3487  *
3488  * @return ROK     - success
3489  *         RFAILED - failure
3490  *
3491  * ****************************************************************/
3492 uint8_t BuildControlRSetToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList)
3493 {
3494    uint8_t idx;
3495    uint8_t elementCnt;
3496    uint8_t numBytes, bitsUnused;
3497    struct ControlResourceSet *controlRSet;
3498    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3499    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3500
3501    if(pdcchCfg == NULLP)
3502       elementCnt = 1;
3503    else
3504       elementCnt = pdcchCfg->numCRsetToAddMod;
3505
3506    controlRSetList->list.count = elementCnt;
3507    controlRSetList->list.size = elementCnt * sizeof(struct ControlResourceSet *);
3508
3509    controlRSetList->list.array = NULLP;
3510    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3511    if(!controlRSetList->list.array)
3512    {
3513       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3514       return RFAILED;
3515    }
3516
3517    for(idx = 0; idx < elementCnt; idx++)
3518    {
3519       controlRSetList->list.array[idx] = NULLP;
3520       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3521       if(!controlRSetList->list.array[idx])
3522       {
3523          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3524          return RFAILED;
3525       }
3526    }
3527
3528    for(idx = 0; idx < elementCnt; idx++)
3529    {
3530       controlRSet = controlRSetList->list.array[idx];
3531
3532       if(pdcchCfg == NULLP)
3533          controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3534       else
3535          controlRSet->controlResourceSetId = pdcchCfg->cRSetToAddModList[idx].cRSetId;
3536
3537       /* size 6 bytes
3538        * 3 LSBs unsued
3539        * Bit string stored ff0000000000
3540        */
3541       numBytes = 6;
3542       bitsUnused = 3;
3543       controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3544
3545       controlRSet->frequencyDomainResources.buf = NULLP;
3546       DU_ALLOC(controlRSet->frequencyDomainResources.buf, controlRSet->frequencyDomainResources.size);
3547       if(!controlRSet->frequencyDomainResources.buf)
3548       {
3549          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3550          return RFAILED;
3551       }
3552
3553       memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3554
3555       if(pdcchCfg == NULLP)
3556       {
3557          coreset0EndPrb = CORESET0_END_PRB;
3558          coreset1StartPrb = coreset0EndPrb + 6;
3559          coreset1NumPrb = CORESET1_NUM_PRB;
3560          /* calculate the PRBs */
3561          fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3562          memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3563          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3564
3565          controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3566          controlRSet->cce_REG_MappingType.present = ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3567          controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3568       }
3569       else
3570       {
3571          memcpy(controlRSet->frequencyDomainResources.buf, pdcchCfg->cRSetToAddModList[idx].freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
3572          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3573          controlRSet->duration = pdcchCfg->cRSetToAddModList[idx].duration;
3574          controlRSet->cce_REG_MappingType.present = pdcchCfg->cRSetToAddModList[idx].cceRegMappingType;
3575          controlRSet->precoderGranularity = pdcchCfg->cRSetToAddModList[idx].precoderGranularity;
3576       }
3577       controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3578       controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3579       controlRSet->tci_PresentInDCI = NULLP;
3580
3581 #if 0
3582       uint8_t tciStateIdx;
3583
3584       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3585             sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3586       if(!controlRset->tci_StatesPDCCH_ToAddList)
3587       {
3588          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3589          return RFAILED;
3590       }
3591
3592       elementCnt = 1;
3593       controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3594       controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3595       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3596             controlRset->tci_StatesPDCCH_ToAddList->list.size)
3597          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3598          {
3599             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3600             return RFAILED;
3601          }
3602
3603       for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3604       {
3605          DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3606          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3607          {
3608             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3609             return RFAILED;
3610          }
3611       }
3612
3613       tciStateIdx = 0;
3614       /* TODO */
3615       *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3616
3617       DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3618       if(!controlRset->tci_PresentInDCI)
3619       {
3620          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3621          return RFAILED;
3622       }
3623       /* TODO */
3624       *(controlRset->tci_PresentInDCI);
3625 #endif
3626
3627       controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3628       DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3629       if(!controlRSet->pdcch_DMRS_ScramblingID)
3630       {
3631          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3632          return RFAILED;
3633       }
3634       if(pdcchCfg == NULLP)
3635          *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3636       else
3637          *(controlRSet->pdcch_DMRS_ScramblingID) = pdcchCfg->cRSetToAddModList[idx].dmrsScramblingId;
3638    }
3639    return ROK;
3640 } /* End BuildControlRSetToAddModList */
3641
3642 /*******************************************************************
3643  *
3644  * @brief Build search space to add/modify list
3645  *
3646  * @details
3647  *
3648  *    Function : BuildSearchSpcToAddModList
3649  *
3650  *    Functionality: Build search space to add/modify list
3651  *
3652  * @params[in]
3653  * @return ROK     - success
3654  *         RFAILED - failure
3655  *
3656  * ****************************************************************/
3657 uint8_t BuildSearchSpcToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
3658 {
3659    uint8_t idx;
3660    uint8_t numBytes;
3661    uint8_t byteIdx;
3662    uint8_t bitsUnused;
3663    uint8_t elementCnt;
3664    struct SearchSpace *searchSpc;
3665
3666    if(pdcchCfg == NULLP)
3667       elementCnt = 1;
3668    else
3669       elementCnt = pdcchCfg->numSearchSpcToAddMod;
3670
3671    searchSpcList->list.count = elementCnt;
3672    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3673
3674    searchSpcList->list.array = NULLP;
3675    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3676    if(!searchSpcList->list.array)
3677    {
3678       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3679       return RFAILED;
3680    }
3681
3682    for(idx = 0; idx < elementCnt; idx++)
3683    {
3684       searchSpcList->list.array[idx] = NULLP;
3685       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3686       if(!searchSpcList->list.array[idx])
3687       {
3688          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3689          return RFAILED;
3690       }
3691    }
3692
3693    for(idx = 0; idx < elementCnt; idx++)
3694    {
3695       searchSpc = searchSpcList->list.array[idx];
3696
3697       if(pdcchCfg == NULLP)
3698          searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3699       else
3700          searchSpc->searchSpaceId = pdcchCfg->searchSpcToAddModList[idx].searchSpaceId;
3701
3702       searchSpc->controlResourceSetId = NULLP;
3703       DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3704       if(!searchSpc->controlResourceSetId)
3705       {
3706          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3707          return RFAILED;
3708       }
3709       if(pdcchCfg == NULLP)
3710          *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3711       else
3712          *(searchSpc->controlResourceSetId) = pdcchCfg->searchSpcToAddModList[idx].cRSetId;
3713
3714       searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3715       DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3716       if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3717       {
3718          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3719          return RFAILED;
3720       }
3721       if(pdcchCfg == NULLP)
3722          searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3723       else
3724          searchSpc->monitoringSlotPeriodicityAndOffset->present = pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset;
3725
3726       searchSpc->duration = NULLP;
3727       searchSpc->monitoringSymbolsWithinSlot = NULLP;
3728       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3729       if(!searchSpc->monitoringSymbolsWithinSlot)
3730       {
3731          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3732          return RFAILED;
3733       }
3734
3735       /* Values taken from reference logs :
3736        * size 2 bytes
3737        * 2 LSBs unsued
3738        * Bit string stores 8000
3739        */
3740       numBytes = 2;
3741       bitsUnused = 2;
3742       searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3743       searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3744       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
3745       if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3746       {
3747          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3748          return RFAILED;
3749       }
3750       if(pdcchCfg == NULLP)
3751       {
3752          byteIdx = 0;
3753          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3754          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3755       }
3756       else
3757          memcpy(searchSpc->monitoringSymbolsWithinSlot->buf, pdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot, numBytes);
3758       searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3759
3760       searchSpc->nrofCandidates = NULLP;
3761       DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3762       if(!searchSpc->nrofCandidates)
3763       {
3764          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3765          return RFAILED;
3766       }
3767
3768       if(pdcchCfg == NULLP)
3769       {
3770          searchSpc->nrofCandidates->aggregationLevel1 = PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3771          searchSpc->nrofCandidates->aggregationLevel2 = PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3772          searchSpc->nrofCandidates->aggregationLevel4 = PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3773          searchSpc->nrofCandidates->aggregationLevel8 = PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3774          searchSpc->nrofCandidates->aggregationLevel16 = PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3775       }
3776       else
3777       {
3778          searchSpc->nrofCandidates->aggregationLevel1 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1;
3779          searchSpc->nrofCandidates->aggregationLevel2 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2;
3780          searchSpc->nrofCandidates->aggregationLevel4 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4;
3781          searchSpc->nrofCandidates->aggregationLevel8 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8;
3782          searchSpc->nrofCandidates->aggregationLevel16 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16;
3783       }
3784
3785       searchSpc->searchSpaceType = NULLP;
3786       DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3787       if(!searchSpc->searchSpaceType)
3788       {
3789          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3790          return RFAILED;
3791       }
3792       if(pdcchCfg == NULLP)
3793          searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3794       else
3795          searchSpc->searchSpaceType->present = pdcchCfg->searchSpcToAddModList[idx].searchSpaceType;
3796
3797       searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3798       DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3799       if(!searchSpc->searchSpaceType->choice.ue_Specific)
3800       {
3801          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3802          return RFAILED;
3803       }
3804       if(pdcchCfg == NULLP)
3805          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3806       else
3807          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = pdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat;
3808    }
3809    return ROK;
3810 }/* End BuildSearchSpcToAddModList */
3811
3812 /*******************************************************************
3813  *
3814  * @brief Builds BWP DL dedicated PDCCH config
3815  *
3816  * @details
3817  *
3818  *    Function : BuildBWPDlDedPdcchCfg
3819  *
3820  *    Functionality: Builds BWP DL dedicated PDCCH config
3821  *
3822  * @params[in] struct PDCCH_Config *pdcchCfg
3823  *
3824  * @return ROK     - success
3825  *         RFAILED - failure
3826  *
3827  * ****************************************************************/
3828 uint8_t BuildBWPDlDedPdcchCfg(PdcchConfig *pdcchCfgDb, struct PDCCH_Config *pdcchCfg)
3829 {
3830    pdcchCfg->controlResourceSetToAddModList = NULLP;
3831    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3832    if(!pdcchCfg->controlResourceSetToAddModList)
3833    {
3834       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3835       return RFAILED;
3836    }
3837
3838    if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
3839    {
3840       DU_LOG("\nERROR  --> F1AP : Failed in BuildControlRSetToAddModList()");
3841       return RFAILED;
3842    }
3843
3844    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3845
3846    pdcchCfg->searchSpacesToAddModList = NULLP;
3847    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3848    if(!pdcchCfg->searchSpacesToAddModList)
3849    {
3850       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3851       return RFAILED;
3852    }
3853
3854    if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
3855    {
3856       DU_LOG("\nERROR  --> F1AP : Failed in BuildSearchSpcToAddModList()");
3857       return RFAILED;
3858    }
3859
3860    pdcchCfg->searchSpacesToReleaseList = NULLP;
3861    pdcchCfg->downlinkPreemption = NULLP;
3862    pdcchCfg->tpc_PUSCH = NULLP;
3863    pdcchCfg->tpc_PUCCH = NULLP;
3864    pdcchCfg->tpc_SRS = NULLP;
3865
3866    return ROK;
3867 }
3868
3869 /*******************************************************************
3870  *
3871  * @brief Builds DMRS DL PDSCH Mapping type A
3872  *
3873  * @details
3874  *
3875  *    Function : BuildDMRSDLPdschMapTypeA
3876  *
3877  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3878  *
3879  * @params[in]
3880  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3881  * @return ROK     - success
3882  *         RFAILED - failure
3883  *
3884  * ****************************************************************/
3885 uint8_t BuildDMRSDLPdschMapTypeA(PdschConfig *pdschCfg, struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg)
3886 {
3887    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3888    dmrsDlCfg->choice.setup = NULLP;
3889    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3890    if(!dmrsDlCfg->choice.setup)
3891    {
3892       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3893       return RFAILED;
3894    }
3895
3896    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3897    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3898    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3899    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3900    {
3901       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3902       return RFAILED;
3903    }
3904    if(pdschCfg == NULLP)
3905       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3906    else
3907       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = pdschCfg->dmrsDlCfgForPdschMapTypeA.addPos;
3908
3909    dmrsDlCfg->choice.setup->maxLength = NULLP;
3910    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3911    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3912    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3913
3914    return ROK;
3915 }
3916
3917 /*******************************************************************
3918  *
3919  * @brief Builds TCI states to add/modify list
3920  *
3921  * @details
3922  *
3923  *    Function : BuildTCIStatesToAddModList
3924  *
3925  *    Functionality:Builds TCI states to add/modify list
3926  *
3927  * @params[in]
3928  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3929  *
3930  * @return ROK     - success
3931  *         RFAILED - failure
3932  *
3933  * ****************************************************************/
3934 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3935 {
3936    return ROK;
3937 }
3938
3939 /*******************************************************************
3940  *
3941  * @brief Builds PDSCH time domain allocation list
3942  *
3943  * @details
3944  *
3945  *    Function : BuildPdschTimeDomAllocList
3946  *
3947  *    Functionality: Builds PDSCH time domain allocation list
3948  *
3949  * @params[in]
3950  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3951  *
3952  * @return ROK     - success
3953  *         RFAILED - failure
3954  *
3955  * ****************************************************************/
3956 uint8_t BuildPdschTimeDomAllocList(PdschConfig *pdschCfg, struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
3957 {
3958    uint8_t idx;
3959    uint8_t elementCnt;
3960    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3961
3962    timeDomAllocList->present = PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3963
3964    timeDomAllocList->choice.setup = NULLP;
3965    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3966    if(!timeDomAllocList->choice.setup)
3967    {
3968       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3969       return RFAILED;
3970    }
3971
3972 if(pdschCfg == NULLP)
3973    elementCnt = 2;
3974 else
3975 elementCnt = pdschCfg->numTimeDomRsrcAlloc;
3976    timeDomAllocList->choice.setup->list.count = elementCnt;
3977    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3978
3979    timeDomAllocList->choice.setup->list.array = NULLP;
3980    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
3981    if(!timeDomAllocList->choice.setup->list.array)
3982    {
3983       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3984       return RFAILED;
3985    }
3986
3987    for(idx = 0; idx < elementCnt; idx++)
3988    {
3989       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3990       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3991             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3992       if(!timeDomAllocList->choice.setup->list.array[idx])
3993       {
3994          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3995          return RFAILED;
3996       }
3997    }
3998
3999    if(pdschCfg == NULLP)
4000    {
4001       idx = 0;
4002       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4003       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4004       if(!timeDomAlloc->k0)
4005       {
4006          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4007          return RFAILED;
4008       }
4009       *(timeDomAlloc->k0) = 0;
4010       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4011       timeDomAlloc->startSymbolAndLength = \
4012                                            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4013
4014       idx++;
4015       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4016       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4017       if(!timeDomAlloc->k0)
4018       {
4019          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4020          return RFAILED;
4021       }
4022       *(timeDomAlloc->k0) = 1;
4023       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4024       timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4025    }
4026    else
4027    {
4028       for(idx = 0; idx < elementCnt; idx++)
4029       {
4030          timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4031          DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4032          if(!timeDomAlloc->k0)
4033          {
4034             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4035             return RFAILED;
4036          }
4037          if(pdschCfg->timeDomRsrcAllociList[idx].k0)
4038             *(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
4039          timeDomAlloc->mappingType = pdschCfg->timeDomRsrcAllociList[idx].mappingType;
4040          timeDomAlloc->startSymbolAndLength = pdschCfg->timeDomRsrcAllociList[idx].startSymbolAndLength;
4041       }
4042    }
4043
4044    return ROK;
4045 }
4046
4047 /*******************************************************************
4048  *
4049  * @brief Builds PDSCH PRB Bundling type
4050  *
4051  * @details
4052  *
4053  *    Function : BuildPdschPrbBundlingType
4054  *
4055  *    Functionality: Builds PDSCH PRB Bundling type
4056  *
4057  * @params[in]
4058  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4059  *
4060  * @return ROK     - success
4061  *         RFAILED - failure
4062  *
4063  * ****************************************************************/
4064 uint8_t BuildPdschPrbBundlingType(PdschConfig *pdschCfg, struct PDSCH_Config__prb_BundlingType *prbBndlType)
4065 {
4066    if(pdschCfg == NULLP)
4067       prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4068    else
4069       prbBndlType->present = pdschCfg->bundlingType;
4070
4071    prbBndlType->choice.staticBundling = NULLP;
4072    DU_ALLOC(prbBndlType->choice.staticBundling, \
4073          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4074    if(!prbBndlType->choice.staticBundling)
4075    {
4076       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4077       return RFAILED;
4078    }
4079    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4080
4081    return ROK;
4082 }
4083
4084 /*******************************************************************
4085  *
4086  * @brief Builds BWP DL dedicated PDSCH config
4087  *
4088  * @details
4089  *
4090  *    Function : BuildBWPDlDedPdschCfg
4091  *
4092  *    Functionality: Builds BWP DL dedicated PDSCH config
4093  *
4094  * @params[in] struct PDSCH_Config *pdschCfg
4095  *
4096  * @return ROK     - success
4097  *         RFAILED - failure
4098  *
4099  * ****************************************************************/
4100 uint8_t BuildBWPDlDedPdschCfg(PdschConfig *pdschCfgDb, struct PDSCH_Config *pdschCfg)
4101 {
4102    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4103
4104    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4105    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4106    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4107    {
4108       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4109       return RFAILED;
4110    }
4111
4112    if(BuildDMRSDLPdschMapTypeA(pdschCfgDb, pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4113    {
4114       return RFAILED;
4115    }
4116
4117    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4118    pdschCfg->tci_StatesToAddModList = NULLP;
4119    pdschCfg->tci_StatesToReleaseList = NULLP;
4120    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4121 #if 0
4122    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4123    if(!pdschCfg->tci_StatesToAddModList)
4124    {
4125       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4126       return RFAILED;
4127    }
4128    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4129    {
4130       return RFAILED;
4131    }
4132 #endif
4133
4134 if(pdschCfgDb == NULLP)
4135    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4136 else
4137 pdschCfg->resourceAllocation = pdschCfgDb->resourceAllocType;
4138
4139    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4140    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4141    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4142    {
4143       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4144       return RFAILED;
4145    }
4146    if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4147    {
4148       return RFAILED;
4149    }
4150
4151    pdschCfg->pdsch_AggregationFactor = NULLP;
4152    pdschCfg->rateMatchPatternToAddModList = NULLP;
4153    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4154    pdschCfg->rateMatchPatternGroup1 = NULLP;
4155    pdschCfg->rateMatchPatternGroup2 = NULLP;
4156    if(pdschCfgDb == NULLP)
4157       pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4158    else
4159       pdschCfg->rbg_Size = pdschCfgDb->rbgSize;
4160    pdschCfg->mcs_Table = NULLP;
4161
4162    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4163    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4164    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4165    {
4166       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4167       return RFAILED;
4168    }
4169    if(pdschCfgDb == NULLP)
4170       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4171    else
4172       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = pdschCfgDb->numCodeWordsSchByDci;
4173
4174    if(BuildPdschPrbBundlingType(pdschCfgDb, &pdschCfg->prb_BundlingType) != ROK)
4175    {
4176       return RFAILED;
4177    }
4178
4179    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4180    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4181    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4182    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4183    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4184    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4185    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4186
4187    return ROK;
4188 }
4189
4190 /*******************************************************************
4191  *
4192  * @brief Builds intitial DL BWP
4193  * @details
4194  *
4195  *    Function : BuildInitialDlBWP
4196  *
4197  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4198  *
4199  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4200  *
4201  * @return ROK     - success
4202  *         RFAILED - failure
4203  *
4204  * ****************************************************************/
4205 uint8_t BuildInitialDlBWP(InitialDlBwp *initiDlBwp, BWP_DownlinkDedicated_t *dlBwp)
4206 {
4207    PdcchConfig *pdcchCfg = NULLP;
4208    PdschConfig *pdschCfg = NULLP;
4209
4210    if(initiDlBwp)
4211    {
4212       if(initiDlBwp->pdcchPresent)
4213          pdcchCfg = &initiDlBwp->pdcchCfg;
4214       if(initiDlBwp->pdschPresent)
4215          pdschCfg = &initiDlBwp->pdschCfg;
4216    }
4217
4218    dlBwp->pdcch_Config = NULLP;
4219    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4220    if(!dlBwp->pdcch_Config)
4221    {
4222       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4223       return RFAILED;
4224    }
4225    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4226
4227    dlBwp->pdcch_Config->choice.setup = NULLP;
4228    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4229    if(!dlBwp->pdcch_Config->choice.setup)
4230    {
4231       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4232       return RFAILED;
4233    }
4234    if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
4235    {
4236       return RFAILED;
4237    }
4238
4239    dlBwp->pdsch_Config = NULLP;
4240    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4241    if(!dlBwp->pdsch_Config)
4242    {
4243       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4244       return RFAILED;
4245    }
4246    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4247
4248    dlBwp->pdsch_Config->choice.setup = NULLP;
4249    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4250    if(!dlBwp->pdsch_Config->choice.setup)
4251    {
4252       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4253       return RFAILED;
4254    }
4255
4256    if(BuildBWPDlDedPdschCfg(pdschCfg, dlBwp->pdsch_Config->choice.setup) != ROK)
4257    {
4258       return RFAILED;
4259    }
4260
4261    dlBwp->sps_Config = NULLP;
4262    dlBwp->radioLinkMonitoringConfig = NULLP;
4263    return ROK;
4264 }
4265
4266 /*******************************************************************
4267  *
4268  * @brief Builds DMRS UL Pusch Mapping type A
4269  *
4270  * @details
4271  *
4272  *    Function : BuildDMRSULPuschMapTypeA
4273  *
4274  *    Functionality: Builds DMRS UL Pusch Mapping type A
4275  *
4276  * @params[in]
4277  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4278  * @return ROK     - success
4279  *         RFAILED - failure
4280  *
4281  * ****************************************************************/
4282 uint8_t BuildDMRSULPuschMapTypeA(DmrsUlCfg *ulDmrsCfgDb, struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg)
4283 {
4284    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4285    dmrsUlCfg->choice.setup= NULLP;
4286    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4287    if(!dmrsUlCfg->choice.setup)
4288    {
4289       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4290       return RFAILED;
4291    }
4292
4293    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4294    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4295    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4296    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4297    {
4298       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4299       return RFAILED;
4300    }
4301    if(ulDmrsCfgDb == NULLP)
4302       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4303    else
4304       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = ulDmrsCfgDb->addPos;
4305
4306    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4307    dmrsUlCfg->choice.setup->maxLength = NULLP;
4308    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4309    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4310    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4311    {
4312       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4313       return RFAILED;
4314    }
4315
4316    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4317    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4318          sizeof(long));
4319    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4320    {
4321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4322       return RFAILED;
4323    }
4324    if(ulDmrsCfgDb == NULLP)
4325       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4326    else
4327       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = ulDmrsCfgDb->transPrecodDisabled.scramblingId0;
4328
4329    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4330    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4331    return ROK;
4332 }
4333
4334 /*******************************************************************
4335  *
4336  * @brief Build PUSCH time domain allocation list
4337  *
4338  * @details
4339  *
4340  *    Function : BuildPuschTimeDomAllocList
4341  *
4342  *    Functionality: Build PUSCH time domain allocation list
4343  *
4344  * @params[in]
4345  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4346  *
4347  * @return ROK     - success
4348  *         RFAILED - failure
4349  *
4350  * ****************************************************************/
4351 uint8_t BuildPuschTimeDomAllocList(PuschCfg *puschCfgDb, struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList)
4352 {
4353    uint8_t idx;
4354    uint8_t elementCnt;
4355    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4356
4357    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4358    timeDomAllocList->choice.setup = NULLP;
4359    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4360    if(!timeDomAllocList->choice.setup)
4361    {
4362       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4363       return RFAILED;
4364    }
4365
4366    if(puschCfgDb == NULLP)
4367       elementCnt = 2;
4368    else
4369       elementCnt = puschCfgDb->numTimeDomRsrcAlloc;
4370
4371    timeDomAllocList->choice.setup->list.count = elementCnt;
4372    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4373    timeDomAllocList->choice.setup->list.array = NULLP;
4374    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4375    if(!timeDomAllocList->choice.setup->list.array)
4376    {
4377       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4378       return RFAILED;
4379    }
4380
4381    for(idx = 0; idx < elementCnt; idx++)
4382    {
4383       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4384       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
4385       if(!timeDomAllocList->choice.setup->list.array[idx])
4386       {
4387          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4388          return RFAILED;
4389       }
4390    }
4391
4392    for(idx = 0; idx < elementCnt; idx++)
4393    {
4394       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4395       DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4396       if(!timeDomAlloc->k2)
4397       {
4398          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4399          return RFAILED;
4400       }
4401       if(puschCfgDb == NULLP)
4402       {
4403          if(idx == 0)
4404             *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4405          else if(idx == 1)
4406             *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4407
4408          timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4409          timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4410       }
4411       else
4412       {
4413          *(timeDomAlloc->k2) = puschCfgDb->timeDomRsrcAllocList[idx].k2;
4414          timeDomAlloc->mappingType = puschCfgDb->timeDomRsrcAllocList[idx].mappingType;
4415          timeDomAlloc->startSymbolAndLength = puschCfgDb->timeDomRsrcAllocList[idx].startSymbolAndLength;
4416       }
4417    }
4418
4419    return ROK;
4420 }
4421
4422 /*******************************************************************
4423  *
4424  * @brief Builds BWP UL dedicated PUSCH Config
4425  *
4426  * @details
4427  *
4428  *    Function : BuildBWPUlDedPuschCfg
4429  *
4430  *    Functionality:
4431  *      Builds BWP UL dedicated PUSCH Config
4432  *
4433  * @params[in] : PUSCH_Config_t *puschCfg
4434  *
4435  * @return ROK     - success
4436  *         RFAILED - failure
4437  *
4438  * ****************************************************************/
4439 uint8_t BuildBWPUlDedPuschCfg(PuschCfg *puschCfgDb, PUSCH_Config_t *puschCfg)
4440 {
4441    DmrsUlCfg *ulDmrsCfg = NULLP;
4442
4443    if(puschCfgDb)
4444       ulDmrsCfg = &puschCfgDb->dmrsUlCfgForPuschMapTypeA;
4445
4446    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4447    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4448    if(!puschCfg->dataScramblingIdentityPUSCH)
4449    {
4450       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4451       return RFAILED;
4452    }
4453    if(puschCfgDb == NULLP)
4454       *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4455    else
4456       *(puschCfg->dataScramblingIdentityPUSCH) = puschCfgDb->dataScramblingId;
4457
4458    puschCfg->txConfig = NULLP;
4459    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4460    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4461    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4462    {
4463       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4464       return RFAILED;
4465    }
4466
4467    if(BuildDMRSULPuschMapTypeA(ulDmrsCfg, puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4468    {
4469       return RFAILED;
4470    }
4471
4472    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4473    puschCfg->pusch_PowerControl = NULLP;
4474    puschCfg->frequencyHopping = NULLP;
4475    puschCfg->frequencyHoppingOffsetLists = NULLP;
4476
4477    if(puschCfgDb == NULLP)
4478       puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4479    else
4480       puschCfg->resourceAllocation = puschCfgDb->resourceAllocType;
4481
4482    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4483    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4484    if(!puschCfg->pusch_TimeDomainAllocationList)
4485    {
4486       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4487       return RFAILED;
4488    }
4489
4490    if(BuildPuschTimeDomAllocList(puschCfgDb, puschCfg->pusch_TimeDomainAllocationList) != ROK)
4491    {
4492       return RFAILED;
4493    }
4494
4495    puschCfg->pusch_AggregationFactor = NULLP;
4496    puschCfg->mcs_Table = NULLP;
4497    puschCfg->mcs_TableTransformPrecoder = NULLP;
4498    puschCfg->transformPrecoder = NULLP;
4499    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4500    if(!puschCfg->transformPrecoder)
4501    {
4502       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4503       return RFAILED;
4504    }
4505    if(puschCfgDb == NULLP)
4506       *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4507    else
4508       *(puschCfg->transformPrecoder) = puschCfgDb->transformPrecoder;
4509
4510    puschCfg->codebookSubset = NULLP;
4511    puschCfg->maxRank = NULLP;
4512    puschCfg->rbg_Size = NULLP;
4513    puschCfg->uci_OnPUSCH = NULLP;
4514    puschCfg->tp_pi2BPSK = NULLP;
4515
4516    return ROK;
4517 }
4518
4519 /*******************************************************************
4520  *
4521  * @brief Builds PUCCH resource set add/modify list
4522  *
4523  * @details
4524  *
4525  *    Function : BuildPucchRsrcSetAddModList
4526  *
4527  *    Functionality:
4528  *      Builds PUCCH resource set add/modify list
4529  *
4530  * @params[in] : PucchResrcSetCfg *rsrcSetCfgDb
4531  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4532  *
4533  * @return ROK     - success
4534  *         RFAILED - failure
4535  *
4536  * ****************************************************************/
4537 uint8_t BuildPucchRsrcSetAddModList(PucchResrcSetCfg *rsrcSetCfgDb, \
4538    struct PUCCH_Config__resourceSetToAddModList *resourceSetToAddModList)
4539 {
4540    uint8_t elementCnt = 0, rsrcSetIdx = 0, rsrcIdx = 0;
4541    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4542
4543    if(rsrcSetCfgDb == NULLP)
4544       elementCnt = 1;
4545    else
4546       elementCnt = rsrcSetCfgDb->resrcSetToAddModListCount;
4547
4548    resourceSetToAddModList->list.count = elementCnt;
4549    resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4550    DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
4551    if(resourceSetToAddModList->list.array == NULLP)
4552    {
4553       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4554       return RFAILED;
4555    }
4556    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4557    {
4558       DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4559       if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4560       {
4561          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4562          return RFAILED;
4563       }
4564    }
4565
4566    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4567    {
4568       rsrcSet = resourceSetToAddModList->list.array[rsrcSetIdx];
4569
4570       /* Resource set Id */
4571       if(rsrcSetCfgDb == NULLP)
4572          rsrcSet->pucch_ResourceSetId = 1;
4573       else
4574          rsrcSet->pucch_ResourceSetId = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcSetId;
4575
4576       /* Resource list of a resource set */
4577       if(rsrcSetCfgDb == NULLP)
4578          elementCnt = 1;
4579       else
4580          elementCnt = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcListCount;
4581       rsrcSet->resourceList.list.count = elementCnt;
4582       rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4583       DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4584       if(rsrcSet->resourceList.list.array == NULLP)
4585       {
4586          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4587          return RFAILED;
4588       }
4589
4590       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4591       {
4592          DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4593          if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4594          {
4595             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4596             return RFAILED;
4597          }
4598       }
4599       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4600       {
4601          if(rsrcSetCfgDb == NULLP)
4602             *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4603          else
4604             *(rsrcSet->resourceList.list.array[rsrcIdx]) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcList[rsrcIdx];
4605       }
4606
4607       /* Max payload size (minus 1) in a Resource set */
4608       rsrcSet->maxPayloadMinus1 = NULLP;
4609       if(rsrcSetCfgDb && rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize)
4610       {
4611          DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
4612          if(rsrcSet->maxPayloadMinus1 == NULLP)
4613          {
4614             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4615             return RFAILED;
4616          }
4617          *(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
4618       }
4619    }
4620    return ROK;
4621 }
4622
4623 /*******************************************************************
4624  *
4625  * @brief Builds PUCCH resource add/modify list
4626  *
4627  * @details
4628  *
4629  *    Function : BuildPucchRsrcAdddModList
4630  *
4631  *    Functionality:
4632  *      Builds PUCCH resource add/modify list
4633  *
4634  * @params[in] : PucchResrcCfg *rsrcSetCfgDb
4635  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4636  *
4637  * @return ROK     - success
4638  *         RFAILED - failure
4639  *
4640  * ****************************************************************/
4641 uint8_t BuildPucchRsrcAddModList(PucchResrcCfg *rsrcCfgDb, struct PUCCH_Config__resourceToAddModList  *resourceToAddModList)
4642 {
4643    uint8_t elementCnt = 0, rsrcIdx = 0;
4644    PUCCH_Resource_t *rsrc = NULLP;
4645
4646    if(rsrcCfgDb == NULLP)
4647       elementCnt = 1;
4648    else
4649       elementCnt = rsrcCfgDb->resrcToAddModListCount;
4650    resourceToAddModList->list.count = elementCnt;
4651    resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4652    DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
4653    if(resourceToAddModList->list.array == NULLP)
4654    {
4655       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4656       return RFAILED;
4657    }
4658    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4659    {
4660       DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4661       if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
4662       {
4663          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4664          return RFAILED;
4665       }
4666    }
4667
4668    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4669    {
4670       rsrc = resourceToAddModList->list.array[rsrcIdx];
4671
4672       if(rsrcCfgDb == NULLP)
4673       {
4674          rsrc->pucch_ResourceId = 1;
4675          rsrc->startingPRB = 0;
4676          rsrc->format.present = PUCCH_Resource__format_PR_format1;
4677          DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4678          if(rsrc->format.choice.format1 == NULLP)
4679          {
4680             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4681             return RFAILED;
4682          }
4683          rsrc->format.choice.format1->initialCyclicShift = 0;
4684          rsrc->format.choice.format1->nrofSymbols = 4;
4685          rsrc->format.choice.format1->startingSymbolIndex = 0;
4686          rsrc->format.choice.format1->timeDomainOCC = 0;
4687       }
4688       else
4689       {
4690          rsrc->pucch_ResourceId = rsrcCfgDb->resrcToAddModList[rsrcIdx].resrcId;
4691          rsrc->startingPRB = rsrcCfgDb->resrcToAddModList[rsrcIdx].startPrb;
4692          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop)
4693          {
4694             DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
4695             if(rsrc->intraSlotFrequencyHopping == NULLP)
4696             {
4697                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4698                return RFAILED;
4699             }
4700             *(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
4701          }
4702          else
4703             rsrc->intraSlotFrequencyHopping = NULLP;
4704
4705          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop)
4706          {
4707             DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
4708             if(rsrc->secondHopPRB == NULLP)
4709             {
4710                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4711                return RFAILED;
4712             }
4713             *(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
4714          }
4715          else
4716             rsrc->secondHopPRB = NULLP;
4717          rsrc->format.present = covertPucchFormatIntEnumToRrcEnum(rsrcCfgDb->resrcToAddModList[rsrcIdx].pucchFormat);
4718
4719          switch(rsrc->format.present)
4720          {
4721             case PUCCH_Resource__format_PR_NOTHING:
4722                break;
4723             case PUCCH_Resource__format_PR_format0:
4724                {
4725                   DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
4726                   if(rsrc->format.choice.format0 == NULLP)
4727                   {
4728                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4729                      return RFAILED;
4730                   }
4731                   rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
4732                   rsrc->format.choice.format0->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->numSymbols;
4733                   rsrc->format.choice.format0->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->startSymbolIdx;
4734                   break;
4735                }
4736
4737             case PUCCH_Resource__format_PR_format1:
4738                {
4739                   DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4740                   if(rsrc->format.choice.format1 == NULLP)
4741                   {
4742                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4743                      return RFAILED;
4744                   }
4745                   rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
4746                   rsrc->format.choice.format1->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->numSymbols;
4747                   rsrc->format.choice.format1->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->startSymbolIdx;
4748                   rsrc->format.choice.format1->timeDomainOCC = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->timeDomOCC;
4749                   break;
4750                }
4751
4752             case PUCCH_Resource__format_PR_format2:
4753                {
4754                   DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
4755                   if(rsrc->format.choice.format2 == NULLP)
4756                   {
4757                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4758                      return RFAILED;
4759                   }
4760                   rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
4761                   rsrc->format.choice.format2->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numSymbols;
4762                   rsrc->format.choice.format2->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->startSymbolIdx;
4763                   break;
4764                }
4765
4766             case PUCCH_Resource__format_PR_format3:
4767                {
4768                   DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
4769                   if(rsrc->format.choice.format3 == NULLP)
4770                   {
4771                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4772                      return RFAILED;
4773                   }
4774                   rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
4775                   rsrc->format.choice.format3->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numSymbols;
4776                   rsrc->format.choice.format3->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->startSymbolIdx;
4777                   break;
4778                }
4779
4780             case PUCCH_Resource__format_PR_format4:
4781                {
4782                   DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
4783                   if(rsrc->format.choice.format4 == NULLP)
4784                   {
4785                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4786                      return RFAILED;
4787                   }
4788                   rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
4789                   rsrc->format.choice.format4->occ_Length = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occLen;
4790                   rsrc->format.choice.format4->occ_Index = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occIdx;
4791                   rsrc->format.choice.format4->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->startSymbolIdx;
4792                   break;
4793                }
4794          }
4795       }
4796    }
4797    return ROK;
4798 }
4799
4800 /*******************************************************************
4801  *
4802  * @brief Builds PUCCH format  config
4803  *
4804  * @details
4805  *
4806  *    Function : BuildPucchFormat
4807  *
4808  *    Functionality: Builds PUCCH format  config
4809  *
4810  * @params[in] : PucchFormatCfg *formatDb
4811  *               PUCCH_FormatConfig_t *format
4812  *
4813  * @return ROK     - success
4814  *         RFAILED - failure
4815  *
4816  * ****************************************************************/
4817 uint8_t BuildPucchFormat(PucchFormatCfg *formatDb, PUCCH_FormatConfig_t *format)
4818 {
4819    /* Inter Slot Fequency hopping */
4820    format->interslotFrequencyHopping = NULLP;
4821    if((formatDb != NULLP) && (formatDb->interSlotFreqHop == true))
4822    {
4823       DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
4824       if(format->interslotFrequencyHopping)
4825       {
4826          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4827          return RFAILED;
4828       }
4829       *(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
4830    }
4831
4832    /* Additional DMRS */
4833    format->additionalDMRS = NULLP;
4834    if((formatDb != NULLP) && (formatDb->addDmrs == true))
4835    {
4836       DU_ALLOC(format->additionalDMRS, sizeof(long));
4837       if(format->additionalDMRS)
4838       {
4839          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4840          return RFAILED;
4841       }
4842       *(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
4843    }
4844
4845     /* Maximum code rate */
4846    format->maxCodeRate = NULLP;
4847    if((formatDb != NULLP) && (formatDb->maxCodeRate != 0))
4848    {
4849       DU_ALLOC(format->maxCodeRate, sizeof(long));
4850       if(format->maxCodeRate)
4851       {
4852          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4853          return RFAILED;
4854       }
4855       *(format->maxCodeRate) = formatDb->maxCodeRate;
4856    }
4857
4858    /* Number of slots */
4859    format->nrofSlots = NULLP;
4860    if((formatDb == NULLP) || ((formatDb != NULLP) && (formatDb->numSlots != 0)))
4861    {
4862       DU_ALLOC(format->nrofSlots, sizeof(long));
4863       if(format->nrofSlots == NULLP)
4864       {
4865          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4866          return RFAILED;
4867       }
4868       if(formatDb == NULLP)
4869          *(format->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4870       else
4871          *(format->nrofSlots) = formatDb->numSlots;
4872    }
4873
4874    /* Pi2BPSK*/
4875    format->pi2BPSK = NULLP;
4876    if((formatDb != NULLP) && (formatDb->pi2BPSK == true))
4877    {
4878       DU_ALLOC(format->pi2BPSK, sizeof(long));
4879       if(format->pi2BPSK)
4880       {
4881          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4882          return RFAILED;
4883       }
4884       *(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
4885    }
4886
4887    /* Simultaneous HARQ ACK and CSI */
4888    format->simultaneousHARQ_ACK_CSI = NULLP;
4889    if((formatDb != NULLP) && (formatDb->harqAckCSI == true))
4890    {
4891       DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
4892       if(format->simultaneousHARQ_ACK_CSI)
4893       {
4894          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4895          return RFAILED;
4896       }
4897       *(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
4898    }
4899
4900    return ROK;
4901 }
4902
4903
4904 /*******************************************************************
4905  *
4906  * @brief Builds PUCCH scheduling request list
4907  *
4908  * @details
4909  *
4910  *    Function : BuildPucchSchReqAddModList
4911  *
4912  *    Functionality:
4913  *      Builds PUCCH scheduling request list
4914  *
4915  * @params[in] : PucchSchedReqCfg *schReqDb
4916  *               struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList
4917  *
4918  * @return ROK     - success
4919  *         RFAILED - failure
4920  *
4921  * ****************************************************************/
4922 uint8_t BuildPucchSchReqAddModList(PucchSchedReqCfg *schReqDb, \
4923    struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList)
4924 {
4925    uint8_t elementCnt = 0, schReqIdx = 0;
4926    SchedulingRequestResourceConfig_t *schReqRsrc;
4927
4928    elementCnt = schReqDb->schedAddModListCount;
4929    schReqRsrcToAddModList->list.count = elementCnt;
4930    schReqRsrcToAddModList->list.size = elementCnt *sizeof(struct SchedulingRequestResourceConfig *);
4931
4932    schReqRsrcToAddModList->list.array = NULLP;
4933    DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
4934    if(schReqRsrcToAddModList->list.array == NULLP)
4935    {
4936       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4937       return RFAILED;
4938    }
4939
4940    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4941    {
4942       DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
4943       if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
4944       {
4945          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4946          return RFAILED;
4947       }
4948    }
4949
4950    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4951    {
4952       schReqRsrc = schReqRsrcToAddModList->list.array[schReqIdx];
4953       schReqRsrc->schedulingRequestResourceId = schReqDb->schedAddModList[schReqIdx].resrcId;
4954       schReqRsrc->schedulingRequestID = schReqDb->schedAddModList[schReqIdx].requestId;
4955
4956       if(schReqDb->schedAddModList[schReqIdx].periodicity)
4957       {
4958          schReqRsrc->periodicityAndOffset = NULLP;
4959          DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
4960          if(schReqRsrc->periodicityAndOffset == NULLP)
4961          {
4962             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4963             return RFAILED;
4964          }
4965
4966          schReqRsrc->periodicityAndOffset->present = schReqDb->schedAddModList[schReqIdx].periodicity;
4967          switch(schReqRsrc->periodicityAndOffset->present)
4968          {
4969             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_NOTHING:
4970                break;
4971             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
4972                schReqRsrc->periodicityAndOffset->choice.sym2 = schReqDb->schedAddModList[schReqIdx].offset;
4973                break;
4974             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
4975                schReqRsrc->periodicityAndOffset->choice.sym6or7 = schReqDb->schedAddModList[schReqIdx].offset;
4976                break;
4977             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
4978                schReqRsrc->periodicityAndOffset->choice.sl1 = schReqDb->schedAddModList[schReqIdx].offset;
4979                break;
4980             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
4981                schReqRsrc->periodicityAndOffset->choice.sl2 = schReqDb->schedAddModList[schReqIdx].offset;
4982                break;
4983             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
4984                schReqRsrc->periodicityAndOffset->choice.sl4 = schReqDb->schedAddModList[schReqIdx].offset;
4985                break;
4986             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
4987                schReqRsrc->periodicityAndOffset->choice.sl5 = schReqDb->schedAddModList[schReqIdx].offset;
4988                break;
4989             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
4990                schReqRsrc->periodicityAndOffset->choice.sl8 = schReqDb->schedAddModList[schReqIdx].offset;
4991                break;
4992             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
4993                schReqRsrc->periodicityAndOffset->choice.sl10 = schReqDb->schedAddModList[schReqIdx].offset;
4994                break;
4995             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
4996                schReqRsrc->periodicityAndOffset->choice.sl16 = schReqDb->schedAddModList[schReqIdx].offset;
4997                break;
4998             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
4999                schReqRsrc->periodicityAndOffset->choice.sl20 = schReqDb->schedAddModList[schReqIdx].offset;
5000                break;
5001             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
5002                schReqRsrc->periodicityAndOffset->choice.sl40 = schReqDb->schedAddModList[schReqIdx].offset;
5003                break;
5004             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
5005                schReqRsrc->periodicityAndOffset->choice.sl80 = schReqDb->schedAddModList[schReqIdx].offset;
5006                break;
5007             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
5008                schReqRsrc->periodicityAndOffset->choice.sl160 = schReqDb->schedAddModList[schReqIdx].offset;
5009                break;
5010             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
5011                schReqRsrc->periodicityAndOffset->choice.sl320 = schReqDb->schedAddModList[schReqIdx].offset;
5012                break;
5013             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
5014                schReqRsrc->periodicityAndOffset->choice.sl640 = schReqDb->schedAddModList[schReqIdx].offset;
5015                break;
5016          }
5017       }
5018
5019       if(schReqDb->schedAddModList[schReqIdx].resrc)
5020       {
5021          schReqRsrc->resource = NULLP;
5022          DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
5023          if(schReqRsrc->resource == NULLP)
5024          {
5025             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5026             return RFAILED;
5027          }
5028          *(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
5029
5030       }
5031    }
5032    return ROK;
5033 }
5034
5035 /*******************************************************************
5036  *
5037  * @brief Builds PUCCH multi csi resource list
5038  *
5039  * @details
5040  *
5041  *    Function : BuildPucchMultiCsiRsrcList
5042  *
5043  *    Functionality:
5044  *      Builds PUCCH multi csi resource list
5045  *
5046  * @params[in] : PucchMultiCsiCfg *multiCsiDb
5047  *               struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList
5048  *
5049  * @return ROK     - success
5050  *         RFAILED - failure
5051  *
5052  * ****************************************************************/
5053 uint8_t BuildPucchMultiCsiRsrcList(PucchMultiCsiCfg *multiCsiDb, struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList)
5054 {
5055    uint8_t elementCnt = 0, rsrcIdx = 0;
5056
5057    elementCnt = multiCsiDb->multiCsiResrcListCount;
5058    multiCsiRsrcList->list.count = elementCnt;
5059    multiCsiRsrcList->list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
5060    multiCsiRsrcList->list.array = NULLP;
5061    DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
5062    if(multiCsiRsrcList->list.array == NULLP)
5063    {
5064       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5065       return RFAILED;
5066    }
5067
5068    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5069    {
5070       DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5071       if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
5072       {
5073          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5074          return RFAILED;
5075       }
5076    }
5077
5078    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5079    {
5080       *(multiCsiRsrcList->list.array[rsrcIdx]) = multiCsiDb->multiCsiResrcList[rsrcIdx];
5081    }
5082    return ROK;
5083 }
5084
5085 /*******************************************************************
5086  *
5087  * @brief Builds DL data -to- Ul Ack list
5088  *
5089  * @details
5090  *
5091  *    Function : BuildDlDataToUlAckList
5092  *
5093  *    Functionality: Builds DL data -to- Ul Ack list
5094  *
5095  * @params[in] : PucchDlDataToUlAck *dlDataToUlAckDb
5096  *               struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList
5097  *
5098  * @return ROK     - success
5099  *         RFAILED - failure
5100  *
5101  * ****************************************************************/
5102 uint8_t BuildDlDataToUlAckList(PucchDlDataToUlAck *dlDataToUlAckDb, struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList)
5103 {
5104    uint8_t elementCnt = 0, arrIdx = 0;
5105
5106    if(dlDataToUlAckDb == NULLP)
5107       elementCnt = 2;
5108    else
5109       elementCnt = dlDataToUlAckDb->dlDataToUlAckListCount;
5110
5111    dlDataToUlACKList->list.count = elementCnt;
5112    dlDataToUlACKList->list.size = elementCnt * sizeof(long *);
5113    DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
5114    if(dlDataToUlACKList->list.array == NULLP)
5115    {
5116       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5117       return RFAILED;
5118    }
5119
5120    for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5121    {
5122       DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
5123       if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
5124       {
5125          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5126          return RFAILED;
5127       }
5128    }
5129
5130    if(dlDataToUlAckDb == NULLP)
5131    {
5132       arrIdx = 0;
5133       *(dlDataToUlACKList->list.array[arrIdx++]) = 1;
5134       *(dlDataToUlACKList->list.array[arrIdx]) = 2;
5135    }
5136    else
5137    {
5138       for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5139       {
5140          *(dlDataToUlACKList->list.array[arrIdx]) = dlDataToUlAckDb->dlDataToUlAckList[arrIdx];
5141       }
5142    }
5143    return ROK;
5144 }
5145
5146 /*******************************************************************
5147  *
5148  * @brief Builds BWP UL dedicated PUCCH Config
5149  *
5150  * @details
5151  *
5152  *    Function : BuildBWPUlDedPucchCfg
5153  *
5154  *    Functionality:
5155  *      Builds BWP UL dedicated PUCCH Config
5156  *
5157  * @params[in] : PUCCH_Config_t *pucchCfg
5158  *
5159  * @return ROK     - success
5160  *         RFAILED - failure
5161  *
5162  * ****************************************************************/
5163 uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg)
5164 {
5165    PucchResrcSetCfg *rsrcSetCfgDb = NULLP;
5166    PucchResrcCfg *rsrcCfgDb = NULLP;
5167    PucchFormatCfg *format1Db = NULLP;
5168    PucchFormatCfg *format2Db = NULLP;
5169    PucchFormatCfg *format3Db = NULLP;
5170    PucchFormatCfg *format4Db = NULLP;
5171    PucchSchedReqCfg *schReqDb = NULLP;
5172    PucchMultiCsiCfg  *multiCsiDb = NULLP;
5173    PucchDlDataToUlAck *dlDataToUlAckDb = NULLP;
5174
5175    if(pucchCfgDb)
5176    {
5177       rsrcSetCfgDb = pucchCfgDb->resrcSet;
5178       rsrcCfgDb = pucchCfgDb->resrc;
5179       format1Db = pucchCfgDb->format1;
5180       format2Db = pucchCfgDb->format2;
5181       format3Db = pucchCfgDb->format3;
5182       format4Db = pucchCfgDb->format4;
5183       schReqDb = pucchCfgDb->schedReq;
5184       multiCsiDb = pucchCfgDb->multiCsiCfg;
5185       dlDataToUlAckDb = pucchCfgDb->dlDataToUlAck;
5186    }
5187
5188    /* RESOURCE SET */
5189    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5190    if(pucchCfg->resourceSetToAddModList == NULL)
5191    {
5192       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5193       return RFAILED;
5194    }
5195
5196    if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
5197    {
5198       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5199       return RFAILED;
5200    }
5201
5202    /* PUCCH RESOURCE */
5203    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5204    if(pucchCfg->resourceToAddModList == NULLP)
5205    {
5206       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5207       return RFAILED;
5208    }
5209
5210    if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
5211    {
5212       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5213       return RFAILED;
5214    }
5215
5216    /* PUCCH Format 1 */
5217    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5218    if(pucchCfg->format1 == NULLP)
5219    {
5220       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5221       return RFAILED;
5222    }
5223
5224    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
5225    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5226    if(pucchCfg->format1->choice.setup == NULLP)
5227    {
5228       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5229       return RFAILED;
5230    }
5231
5232    if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
5233    {
5234       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5235       return RFAILED;
5236    }
5237
5238    /* PUCCH Format 2 */
5239    if(format2Db)
5240    {
5241       DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
5242       if(pucchCfg->format2 == NULLP)
5243       {
5244          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5245          return RFAILED;
5246       }
5247
5248       pucchCfg->format2->present = PUCCH_Config__format2_PR_setup;
5249       DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
5250       if(pucchCfg->format2->choice.setup == NULLP)
5251       {
5252          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5253          return RFAILED;
5254       }
5255
5256       if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
5257       {
5258          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5259          return RFAILED;
5260       }
5261    }
5262
5263    /* PUCCH Format 3 */
5264    if(format3Db)
5265    {
5266       DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
5267       if(pucchCfg->format3 == NULLP)
5268       {
5269          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5270          return RFAILED;
5271       }
5272
5273       pucchCfg->format3->present = PUCCH_Config__format3_PR_setup;
5274       DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
5275       if(pucchCfg->format3->choice.setup == NULLP)
5276       {
5277          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5278          return RFAILED;
5279       }
5280
5281       if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
5282       {
5283          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5284          return RFAILED;
5285       }
5286    }
5287
5288    /* PUCCH Format 4 */
5289    if(format4Db)
5290    {
5291       DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
5292       if(pucchCfg->format4 == NULLP)
5293       {
5294          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5295          return RFAILED;
5296       }
5297
5298       pucchCfg->format4->present = PUCCH_Config__format4_PR_setup;
5299       DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
5300       if(pucchCfg->format4->choice.setup == NULLP)
5301       {
5302          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5303          return RFAILED;
5304       }
5305
5306       if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
5307       {
5308          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5309          return RFAILED;
5310       }
5311    }
5312
5313    /* Scheduling Request */
5314    if(schReqDb && (schReqDb->schedAddModListCount != 0))
5315    {
5316       pucchCfg->schedulingRequestResourceToAddModList = NULLP;
5317       DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
5318       if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
5319       {
5320          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5321          return RFAILED;
5322       }
5323
5324       if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
5325       {
5326          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5327          return RFAILED;
5328       }
5329    }
5330
5331    /* Multi CSI */
5332    if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
5333    {
5334       pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP;
5335       DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
5336       if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
5337       {
5338          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5339          return RFAILED;
5340       }
5341
5342       if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
5343       {
5344          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5345          return RFAILED;
5346       }
5347    }
5348
5349    /* DL DATA TO UL ACK */
5350    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5351    if(pucchCfg->dl_DataToUL_ACK == NULLP)
5352    {
5353       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5354       return RFAILED;
5355    }
5356
5357    if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
5358    {
5359       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5360       return RFAILED;
5361    }
5362
5363    /* TODO : spatial relation info add/mod list and power control*/
5364
5365    return ROK;
5366 }
5367
5368 /*******************************************************************
5369  *
5370  * @brief Fills SRS resource to add/modify list
5371  *
5372  * @details
5373  *
5374  *    Function : BuildSrsRsrcAddModList
5375  *
5376  *    Functionality: Fills SRS resource to add/modify list
5377  *
5378  * @params[in]
5379  * @return ROK     - success
5380  *         RFAILED - failure
5381  *
5382  * ****************************************************************/
5383 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
5384 {
5385    uint8_t   elementCnt;
5386    uint8_t   rsrcIdx;
5387
5388    elementCnt = 1;
5389    resourceList->list.count = elementCnt;
5390    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
5391    resourceList->list.array = NULLP;
5392    DU_ALLOC(resourceList->list.array, resourceList->list.size);
5393    if(!resourceList->list.array)
5394    {
5395       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5396       return RFAILED;
5397    }
5398
5399    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5400    {
5401       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5402       if(!resourceList->list.array[rsrcIdx])
5403       {
5404          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5405          return RFAILED;
5406       }
5407    }
5408
5409    rsrcIdx = 0;
5410    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
5411    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
5412    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
5413
5414    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
5415    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
5416          sizeof(struct SRS_Resource__transmissionComb__n2));
5417    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
5418    {
5419       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5420       return RFAILED;
5421    }
5422    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
5423       = SRS_COMB_OFFSET_N2;
5424    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
5425       = SRS_CYCLIC_SHIFT_N2;
5426
5427    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
5428                                                                       PUSCH_START_SYMBOL;
5429    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
5430                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
5431    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
5432                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
5433
5434    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
5435    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
5436    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
5437    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
5438    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
5439    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
5440                                                                SRS_Resource__groupOrSequenceHopping_neither;
5441
5442    /* Setting resource type to aperiodic for intergration purposes */
5443    resourceList->list.array[rsrcIdx]->resourceType.present = \
5444                                                              SRS_Resource__resourceType_PR_aperiodic;
5445    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
5446    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
5447          sizeof(struct SRS_Resource__resourceType__aperiodic));
5448    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
5449    {
5450       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5451       return RFAILED;
5452    }
5453    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
5454
5455    return ROK;
5456 }
5457
5458 /*******************************************************************
5459  *
5460  * @brief Build SRS resource set Add/mod list
5461  *
5462  * @details
5463  *
5464  *    Function : BuildSrsRsrcSetAddModList
5465  *
5466  *    Functionality: Build SRS resource set Add/mod list
5467  *
5468  * @params[in]
5469  * @return ROK     - success
5470  *         RFAILED - failure
5471  *
5472  * ****************************************************************/
5473    uint8_t BuildSrsRsrcSetAddModList
5474 (
5475  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
5476  )
5477 {
5478    uint8_t  elementCnt;
5479    uint8_t  rSetIdx;
5480    uint8_t  rsrcIdx;
5481    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
5482
5483    elementCnt = 1;
5484    rsrcSetList->list.count = elementCnt;
5485    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
5486    rsrcSetList->list.array = NULLP;
5487    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
5488    if(!rsrcSetList->list.array)
5489    {
5490       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5491       return RFAILED;
5492    }
5493
5494    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5495    {
5496       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5497       if(!rsrcSetList->list.array[rSetIdx])
5498       {
5499          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5500          return RFAILED;
5501       }
5502    }
5503
5504    rSetIdx = 0;
5505    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
5506
5507    /* Fill Resource Id list in resource set */
5508    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
5509    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5510          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5511    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5512    {
5513       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5514       return RFAILED;
5515    }
5516
5517    elementCnt = 1;
5518    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5519    rsrcIdList->list.count = elementCnt;
5520    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
5521    rsrcIdList->list.array = NULLP;
5522    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
5523    if(!rsrcIdList->list.array)
5524    {
5525       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5526       return RFAILED;
5527    }
5528
5529    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5530    {
5531       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5532       if(!rsrcIdList->list.array[rsrcIdx])
5533       {
5534          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5535          return RFAILED;
5536       }
5537    }
5538
5539    rsrcIdx = 0;
5540    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
5541
5542    /* Fill resource type */
5543    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
5544                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
5545
5546    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
5547    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5548          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5549    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
5550    {
5551       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5552       return RFAILED;
5553    }
5554    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
5555       = APERIODIC_SRS_RESRC_TRIGGER;
5556
5557    /* TODO : Fill values for below IEs as expected by Viavi */
5558    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
5559    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
5560
5561
5562    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
5563    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
5564    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
5565    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
5566    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
5567
5568    return ROK;
5569 }
5570
5571 /*******************************************************************
5572  *
5573  * @brief Builds BWP UL dedicated SRS Config
5574  *
5575  * @details
5576  *
5577  *    Function : BuildBWPUlDedSrsCfg
5578  *
5579  *    Functionality: Builds BWP UL dedicated SRS Config
5580  *
5581  * @params[in] SRS Config
5582  * @return ROK     - success
5583  *         RFAILED - failure
5584  *
5585  * ****************************************************************/
5586 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
5587 {
5588    srsCfg->srs_ResourceSetToReleaseList = NULLP;
5589    srsCfg->srs_ResourceSetToAddModList = NULLP;
5590    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
5591          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5592    if(!srsCfg->srs_ResourceSetToAddModList)
5593    {
5594       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5595       return RFAILED;
5596    }
5597    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
5598    {
5599       return RFAILED;
5600    }
5601
5602    srsCfg->srs_ResourceToReleaseList = NULLP;
5603
5604    /* Resource to Add/Modify list */
5605    srsCfg->srs_ResourceToAddModList = NULLP;
5606    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
5607          sizeof(struct SRS_Config__srs_ResourceToAddModList));
5608    if(!srsCfg->srs_ResourceToAddModList)
5609    {
5610       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5611       return RFAILED;
5612    }
5613
5614    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
5615    {
5616       return RFAILED;
5617    }
5618
5619    srsCfg->tpc_Accumulation = NULLP;
5620
5621    return ROK;
5622 }
5623
5624
5625
5626 /*******************************************************************
5627  *
5628  * @brief Builds Pusch Serving cell Config
5629  *
5630  * @details
5631  *
5632  *    Function : BuildPuschSrvCellCfg
5633  *
5634  *    Functionality: Builds Pusch Serving cell Config
5635  *
5636  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
5637  *
5638  * @return ROK     - success
5639  *         RFAILED - failure
5640  *
5641  * ****************************************************************/
5642 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
5643 {
5644    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
5645    puschCfg->choice.setup = NULLP;
5646    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5647    if(!puschCfg->choice.setup)
5648    {
5649       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5650       return RFAILED;
5651    }
5652
5653    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5654    puschCfg->choice.setup->rateMatching = NULLP;
5655    puschCfg->choice.setup->xOverhead = NULLP;
5656    puschCfg->choice.setup->ext1 = NULLP;
5657    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
5658    if(!puschCfg->choice.setup->ext1)
5659    {
5660       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5661       return RFAILED;
5662    }
5663
5664    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
5665    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5666    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
5667    {
5668       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5669       return RFAILED;
5670    }
5671    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5672
5673    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5674    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5675    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5676    {
5677       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5678       return RFAILED;
5679    }
5680    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5681    return ROK;
5682 }
5683
5684 /*******************************************************************
5685  *
5686  * @brief Builds inital UL BWP
5687  *
5688  * @details
5689  *
5690  *    Function : BuildInitialUlBWP
5691  *
5692  *    Functionality: Builds initial UL BWP
5693  *
5694  * @params[in] BWP_UplinkDedicated_t *ulBwp
5695  * @return ROK     - success
5696  *         RFAILED - failure
5697  *
5698  * ****************************************************************/
5699 uint8_t BuildInitialUlBWP(InitialUlBwp *initUlBwp, BWP_UplinkDedicated_t *ulBwp)
5700 {
5701    PucchCfg *pucchCfg = NULLP;
5702    PuschCfg *puschCfg = NULLP;
5703
5704    if(initUlBwp)
5705    {
5706       if(initUlBwp->pucchPresent)
5707          pucchCfg = &initUlBwp->pucchCfg;
5708       if(initUlBwp->puschPresent)
5709          puschCfg = &initUlBwp->puschCfg;
5710    }
5711
5712    ulBwp->pucch_Config = NULLP;
5713    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5714    if(!ulBwp->pucch_Config)
5715    {
5716       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5717       return RFAILED;
5718    }
5719
5720    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
5721    ulBwp->pucch_Config->choice.setup = NULLP;
5722    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5723    if(!ulBwp->pucch_Config->choice.setup)
5724    {
5725       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5726       return RFAILED;
5727    }
5728
5729    if(BuildBWPUlDedPucchCfg(pucchCfg, ulBwp->pucch_Config->choice.setup) != ROK)
5730    {
5731       return RFAILED;
5732    }
5733
5734    /* Fill BWP UL dedicated PUSCH config */
5735    ulBwp->pusch_Config = NULLP;
5736    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5737    if(!ulBwp->pusch_Config)
5738    {
5739       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5740       return RFAILED;
5741    }
5742
5743    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
5744    ulBwp->pusch_Config->choice.setup = NULLP;
5745    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5746    if(!ulBwp->pusch_Config->choice.setup)
5747    {
5748       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5749       return RFAILED;
5750    }
5751
5752    if(BuildBWPUlDedPuschCfg(puschCfg, ulBwp->pusch_Config->choice.setup) != ROK)
5753    {
5754       return RFAILED;
5755    }
5756
5757    ulBwp->configuredGrantConfig = NULLP;
5758
5759    /* Fill BPW UL dedicated SRS config */
5760    ulBwp->srs_Config = NULLP;
5761    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5762    if(!ulBwp->srs_Config)
5763    {
5764       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5765       return RFAILED;
5766    }
5767
5768    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
5769    ulBwp->srs_Config->choice.setup = NULLP;
5770    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5771    if(!ulBwp->srs_Config->choice.setup)
5772    {
5773       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5774       return RFAILED;
5775    }
5776
5777    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
5778    {
5779       return RFAILED;
5780    }
5781
5782    ulBwp->beamFailureRecoveryConfig = NULLP;
5783
5784    return ROK;
5785 }
5786
5787 /*******************************************************************
5788  *
5789  * @brief Builds UL config
5790  * @details
5791  *
5792  *    Function : BuildUlCfg
5793  *
5794  *    Functionality: Builds UL config in spCellCfgDed
5795  *
5796  * @params[in] UplinkConfig_t *ulCfg
5797  *
5798  * @return ROK     - success
5799  *         RFAILED - failure
5800  *
5801  * ****************************************************************/
5802 uint8_t BuildUlCfg(ServCellCfgInfo *servCellCfg, UplinkConfig_t *ulCfg)
5803 {
5804    InitialUlBwp *initUlBwp = NULLP;
5805
5806    if(servCellCfg)
5807    {
5808       initUlBwp = &servCellCfg->initUlBwp;
5809    }
5810
5811    ulCfg->initialUplinkBWP = NULLP;
5812    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5813    if(!ulCfg->initialUplinkBWP)
5814    {
5815       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5816       return RFAILED;
5817    }
5818
5819    if(BuildInitialUlBWP(initUlBwp, ulCfg->initialUplinkBWP) != ROK)
5820    {
5821       return RFAILED;
5822    }
5823
5824    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5825    ulCfg->uplinkBWP_ToAddModList = NULLP;
5826    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5827    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5828    if(!ulCfg->firstActiveUplinkBWP_Id)
5829    {
5830       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5831       return RFAILED;
5832    }
5833    if(servCellCfg == NULLP)
5834       *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5835    else
5836       *(ulCfg->firstActiveUplinkBWP_Id) = servCellCfg->firstActvUlBwpId;
5837
5838    ulCfg->pusch_ServingCellConfig = NULLP;
5839    DU_ALLOC(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5840    if(!ulCfg->pusch_ServingCellConfig)
5841    {
5842       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5843       return RFAILED;
5844    }
5845
5846    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5847    {
5848       return RFAILED;
5849    }
5850
5851    ulCfg->carrierSwitching = NULLP;
5852    ulCfg->ext1 = NULLP;
5853    return ROK;
5854 }
5855
5856 /*******************************************************************
5857  *
5858  * @brief Builds PDSCH serving cell config
5859  * @details
5860  *
5861  *    Function : BuildPdschSrvCellCfg
5862  *
5863  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5864  *
5865  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5866  *
5867  * @return ROK     - success
5868  *         RFAILED - failure
5869  *
5870  * ****************************************************************/
5871 uint8_t BuildPdschSrvCellCfg(PdschServCellCfg *pdschServCellDb, struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5872 {
5873    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5874    pdschCfg->choice.setup = NULLP;
5875    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5876    if(!pdschCfg->choice.setup)
5877    {
5878       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5879       return RFAILED;
5880    }
5881
5882    /* Code Block Group Transmission */
5883    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5884    if(pdschServCellDb && (pdschServCellDb->maxCodeBlkGrpPerTb || pdschServCellDb->codeBlkGrpFlushInd))
5885    {
5886       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission, sizeof(struct PDSCH_ServingCellConfig__codeBlockGroupTransmission));
5887       if(pdschCfg->choice.setup->codeBlockGroupTransmission == NULLP)
5888       {
5889          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5890          return RFAILED;
5891       }
5892
5893       pdschCfg->choice.setup->codeBlockGroupTransmission->present = PDSCH_ServingCellConfig__codeBlockGroupTransmission_PR_setup;
5894       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup = NULLP;
5895       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup, sizeof(struct PDSCH_CodeBlockGroupTransmission ));
5896       if(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup == NULLP)
5897       {
5898          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5899          return RFAILED;
5900       }
5901
5902       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock = \
5903          *(pdschServCellDb->maxCodeBlkGrpPerTb);
5904       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator = \
5905          *(pdschServCellDb->codeBlkGrpFlushInd);
5906    }
5907
5908    /* xOverhead */
5909    pdschCfg->choice.setup->xOverhead = NULLP;
5910    if(pdschServCellDb && pdschServCellDb->xOverhead)
5911    {
5912       DU_ALLOC(pdschCfg->choice.setup->xOverhead, sizeof(long));
5913       if(pdschCfg->choice.setup->xOverhead == NULLP)
5914       {
5915          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5916          return RFAILED;
5917       }
5918       *(pdschCfg->choice.setup->xOverhead) = *(pdschServCellDb->xOverhead);
5919    }
5920
5921    /* Number of HARQ processes */
5922    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5923    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5924    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5925    {
5926       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5927       return RFAILED;
5928    }
5929
5930    if(pdschServCellDb == NULLP)
5931    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = PDSCH_NUM_HARQ_PROC;
5932    else
5933    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = pdschServCellDb->numHarqProcForPdsch;
5934
5935    pdschCfg->choice.setup->pucch_Cell = NULLP;
5936
5937    /* Extension */
5938    pdschCfg->choice.setup->ext1 = NULLP;
5939    if(pdschServCellDb && pdschServCellDb->maxMimoLayers)
5940    {
5941       DU_ALLOC(pdschCfg->choice.setup->ext1, sizeof(struct PDSCH_ServingCellConfig__ext1));
5942       if(pdschCfg->choice.setup->ext1 == NULLP)
5943       {
5944          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5945          return RFAILED;
5946       }
5947
5948       DU_ALLOC(pdschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5949       if(pdschCfg->choice.setup->ext1->maxMIMO_Layers == NULLP)
5950       {
5951          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5952          return RFAILED;
5953       }
5954       *(pdschCfg->choice.setup->ext1->maxMIMO_Layers) = *(pdschServCellDb->maxMimoLayers);
5955    }
5956
5957    return ROK;
5958 }
5959
5960 /*******************************************************************
5961  *
5962  * @brief Builds CSI Meas config
5963  * @details
5964  *
5965  *    Function : BuildCsiMeasCfg
5966  *
5967  *    Functionality: Builds CSI Meas config in spCellCfgDed
5968  *
5969  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5970  *
5971  * @return ROK     - success
5972  *         RFAILED - failure
5973  *
5974  * ****************************************************************/
5975 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5976 {
5977
5978    return ROK;
5979 }
5980
5981 /*******************************************************************
5982  *
5983  * @brief Builds DL BWP to add/modify list
5984  * @details
5985  *
5986  *    Function : BuildDlBwpToAddModList
5987  *
5988  *    Functionality: Builds DL BWP to add/modify list
5989  *
5990  * @params[in] ServCellCfgInfo *servCellCfg,
5991  *             struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList
5992  *
5993  * @return ROK     - success
5994  *         RFAILED - failure
5995  *
5996  * ****************************************************************/
5997 uint8_t BuildDlBwpToAddModList(ServCellCfgInfo *servCellCfg, struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList)
5998 {
5999    uint8_t elementCnt, idx;
6000
6001    elementCnt = servCellCfg->numDlBwpToAdd;
6002    dlBwpAddModList->list.count = elementCnt;
6003    dlBwpAddModList->list.size = elementCnt * sizeof(struct BWP_Downlink *);
6004    dlBwpAddModList->list.array = NULLP;
6005    DU_ALLOC(dlBwpAddModList->list.array, dlBwpAddModList->list.size);
6006    if(dlBwpAddModList->list.array == NULLP)
6007    {
6008       DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6009       return RFAILED;
6010    }
6011
6012    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6013    {
6014       DU_ALLOC(dlBwpAddModList->list.array[idx], sizeof(BWP_Downlink_t));
6015       if(dlBwpAddModList->list.array[idx] == NULLP)
6016       {
6017          DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6018          return RFAILED;
6019       }
6020    }
6021
6022    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6023    {
6024       dlBwpAddModList->list.array[idx]->bwp_Id = servCellCfg->DlBwpToAddList[idx].bwpId;
6025       dlBwpAddModList->list.array[idx]->bwp_Common = NULLP;
6026       dlBwpAddModList->list.array[idx]->bwp_Dedicated = NULLP;
6027    }
6028    return ROK;
6029 }
6030
6031 /*******************************************************************
6032  *
6033  * @brief Builds Spcell config dedicated
6034  * @details
6035  *
6036  *    Function : BuildSpCellCfgDed
6037  *
6038  *    Functionality: Builds sp cell config dedicated in spCellCfg
6039  *
6040  * @params[in] ServingCellConfig_t srvCellCfg
6041  *
6042  * @return ROK     - success
6043  *         RFAILED - failure
6044  *
6045  * ****************************************************************/
6046 uint8_t BuildSpCellCfgDed(DuUeCb *ueCb, ServingCellConfig_t *srvCellCfg)
6047 {
6048    ServCellCfgInfo *servCellCfg = NULLP;
6049    InitialDlBwp *initDlBwp = NULLP;
6050    PdschServCellCfg *pdschServCellDb = NULLP;
6051
6052    if(ueCb)
6053    {
6054       servCellCfg = &ueCb->macUeCfg.spCellCfg.servCellCfg;
6055       initDlBwp = &servCellCfg->initDlBwp;
6056       pdschServCellDb = &servCellCfg->pdschServCellCfg;
6057    }
6058
6059    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
6060    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
6061    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
6062    {
6063       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6064       return RFAILED;
6065    }
6066
6067    srvCellCfg->initialDownlinkBWP = NULLP;
6068    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6069    if(!srvCellCfg->initialDownlinkBWP)
6070    {
6071       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6072       return RFAILED;
6073    }
6074
6075    if(BuildInitialDlBWP(initDlBwp, srvCellCfg->initialDownlinkBWP) != ROK)
6076    {
6077       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6078       return RFAILED;
6079    }
6080
6081    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
6082
6083    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
6084    if(ueCb && ueCb->macUeCfg.spCellCfg.servCellCfg.numDlBwpToAdd)
6085    {
6086       DU_ALLOC(srvCellCfg->downlinkBWP_ToAddModList, sizeof(struct ServingCellConfig__downlinkBWP_ToAddModList));
6087       if(srvCellCfg->downlinkBWP_ToAddModList == NULLP)
6088       {
6089          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6090          return RFAILED;
6091       }
6092
6093       if(BuildDlBwpToAddModList(&ueCb->macUeCfg.spCellCfg.servCellCfg, srvCellCfg->downlinkBWP_ToAddModList) != ROK)
6094       {
6095          DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6096          return RFAILED;
6097       }
6098    }
6099
6100    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
6101    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6102    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
6103    {
6104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6105       return RFAILED;
6106    }
6107    if(ueCb == NULLP)
6108       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6109    else
6110       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.firstActvDlBwpId;
6111
6112    srvCellCfg->bwp_InactivityTimer = NULLP;
6113
6114    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
6115    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6116    if(!srvCellCfg->defaultDownlinkBWP_Id)
6117    {
6118       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6119       return RFAILED;
6120    }
6121    if(ueCb == NULLP)
6122       *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6123    else
6124       *(srvCellCfg->defaultDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.defaultDlBwpId;
6125
6126    srvCellCfg->uplinkConfig = NULLP;
6127    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6128    if(!srvCellCfg->uplinkConfig)
6129    {
6130       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6131       return RFAILED;
6132    }
6133
6134    if(BuildUlCfg(servCellCfg, srvCellCfg->uplinkConfig) != ROK)
6135    {
6136       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
6137       return RFAILED;
6138    }
6139    srvCellCfg->supplementaryUplink = NULLP;
6140    srvCellCfg->pdcch_ServingCellConfig = NULLP;
6141
6142    srvCellCfg->pdsch_ServingCellConfig = NULLP;
6143    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
6144    if(!srvCellCfg->pdsch_ServingCellConfig)
6145    {
6146       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6147       return RFAILED;
6148    }
6149
6150    if(BuildPdschSrvCellCfg(pdschServCellDb, srvCellCfg->pdsch_ServingCellConfig) != ROK)
6151    {
6152       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
6153       return RFAILED;
6154    }
6155
6156    srvCellCfg->csi_MeasConfig = NULLP;
6157 #if 0
6158    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
6159       if(!srvCellCfg->csi_MeasConfig)
6160       {
6161          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6162          return RFAILED;
6163       }
6164
6165    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
6166    {
6167       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
6168       return RFAILED;
6169    }
6170 #endif
6171    srvCellCfg->sCellDeactivationTimer = NULLP;
6172    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
6173    srvCellCfg->tag_Id = TAG_ID;
6174    srvCellCfg->dummy = NULLP;
6175    srvCellCfg->pathlossReferenceLinking = NULLP;
6176    srvCellCfg->servingCellMO = NULLP;
6177    srvCellCfg->ext1 = NULLP;
6178
6179    return ROK;
6180 }
6181 /*******************************************************************
6182  *
6183  * @brief Builds Spcell config
6184  *
6185  * @details
6186  *
6187  *    Function : BuildSpCellCfg
6188  *
6189  *    Functionality: Builds sp cell config in DuToCuRrcContainer
6190  *
6191  * @params[in] SpCellConfig_t spCellCfg
6192  *
6193  * @return ROK     - success
6194  *         RFAILED - failure
6195  *
6196  * ****************************************************************/
6197 uint8_t BuildSpCellCfg(DuUeCb *ueCb, SpCellConfig_t *spCellCfg)
6198 {
6199    spCellCfg->servCellIndex = NULLP;
6200    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
6201    if(!spCellCfg->servCellIndex)
6202    {
6203       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6204       return RFAILED;
6205    }
6206
6207    if(ueCb == NULLP)
6208       *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
6209    else
6210       *(spCellCfg->servCellIndex) = ueCb->macUeCfg.spCellCfg.servCellIdx;
6211
6212    spCellCfg->reconfigurationWithSync = NULLP;
6213    spCellCfg->rlf_TimersAndConstants = NULLP;
6214    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
6215
6216    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6217    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
6218    {
6219       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6220       return RFAILED;
6221    }
6222    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
6223
6224    spCellCfg->spCellConfigDedicated = NULLP;
6225    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6226    if(!spCellCfg->spCellConfigDedicated)
6227    {
6228       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6229       return RFAILED;
6230    }
6231    if(BuildSpCellCfgDed(ueCb, spCellCfg->spCellConfigDedicated) != ROK)
6232    {
6233       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
6234       return RFAILED;
6235    }
6236
6237    return ROK;
6238 }
6239
6240 /*******************************************************************
6241  *
6242  * @brief Builds Phy cell group config
6243  *
6244  * @details
6245  *
6246  *    Function : BuildPhyCellGrpCfg
6247  *
6248  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
6249  *
6250  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
6251  *
6252  * @return ROK     - success
6253  *         RFAILED - failure
6254  *
6255  * ****************************************************************/
6256 uint8_t BuildPhyCellGrpCfg(DuUeCb *ueCb, PhysicalCellGroupConfig_t *phyCellGrpCfg)
6257 {
6258    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
6259    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
6260
6261    phyCellGrpCfg->p_NR_FR1 = NULLP;
6262    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6263    if(!phyCellGrpCfg->p_NR_FR1)
6264    {
6265       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
6266       return RFAILED;
6267    }
6268
6269    if(ueCb == NULLP)
6270    {
6271       *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
6272       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
6273    }
6274    else
6275    {
6276       *(phyCellGrpCfg->p_NR_FR1) = ueCb->macUeCfg.phyCellGrpCfg.pNrFr1;
6277       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = ueCb->macUeCfg.phyCellGrpCfg.pdschHarqAckCodebook;
6278    }
6279
6280    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
6281    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
6282    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
6283    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
6284    phyCellGrpCfg->cs_RNTI = NULLP;
6285    phyCellGrpCfg->ext1 = NULLP;
6286    phyCellGrpCfg->ext2 = NULLP;
6287
6288    return ROK;
6289 }
6290
6291 /*******************************************************************
6292  *
6293  * @brief Builds Mac cell group config
6294  *
6295  * @details
6296  *
6297  *    Function : BuildMacCellGrpCfg
6298  *
6299  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
6300  *
6301  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
6302  *
6303  * @return ROK     - success
6304  *         RFAILED - failure
6305  *
6306  * ****************************************************************/
6307 uint8_t BuildMacCellGrpCfg(DuUeCb *ueCb, MAC_CellGroupConfig_t *macCellGrpCfg)
6308 {
6309    macCellGrpCfg->drx_Config = NULLP;
6310    macCellGrpCfg->schedulingRequestConfig = NULLP;
6311    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6312    if(!macCellGrpCfg->schedulingRequestConfig)
6313    {
6314       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6315       return RFAILED;
6316    }
6317
6318    if(BuildSchedulingReqConfig(ueCb, macCellGrpCfg->schedulingRequestConfig) != ROK)
6319    {
6320       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
6321       return RFAILED;
6322    }
6323
6324    macCellGrpCfg->bsr_Config = NULLP;
6325    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6326    if(!macCellGrpCfg->bsr_Config)
6327    {
6328       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6329       return RFAILED;
6330    }
6331
6332    if(BuildBsrConfig(ueCb, macCellGrpCfg->bsr_Config) != ROK)
6333    {
6334       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
6335       return RFAILED;
6336    }
6337
6338    macCellGrpCfg->tag_Config = NULLP;
6339    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
6340    if(!macCellGrpCfg->tag_Config)
6341    {
6342       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6343       return RFAILED;
6344    }
6345
6346    if(BuildTagConfig(ueCb, macCellGrpCfg->tag_Config) != ROK)
6347    {
6348       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
6349       return RFAILED;
6350    }
6351
6352    macCellGrpCfg->phr_Config = NULLP;
6353    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
6354    if(!macCellGrpCfg->phr_Config)
6355    {
6356       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6357       return RFAILED;
6358    }
6359
6360    if(BuildPhrConfig(ueCb, macCellGrpCfg->phr_Config) != ROK)
6361    {
6362       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
6363       return RFAILED;
6364    }
6365
6366    macCellGrpCfg->skipUplinkTxDynamic = false;
6367    macCellGrpCfg->ext1 = NULLP;
6368
6369    return ROK;
6370 }
6371 /*******************************************************************
6372  *
6373  * @brief Frees memeory allocated for SearchSpcToAddModList
6374  *
6375  * @details
6376  *
6377  *    Function : FreeSearchSpcToAddModList
6378  *
6379  *    Functionality: Deallocating memory of SearchSpcToAddModList
6380  *
6381  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6382  *
6383  * @return void
6384  *
6385  4221 * ****************************************************************/
6386 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6387 {
6388    uint8_t idx1=0;
6389    uint8_t idx2=0;
6390    struct  SearchSpace *searchSpc=NULLP;
6391
6392    if(searchSpcList->list.array)
6393    {
6394       if(searchSpcList->list.array[idx2])
6395       {
6396          searchSpc = searchSpcList->list.array[idx2];
6397          if(searchSpc->controlResourceSetId)
6398          {
6399             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6400             {
6401                if(searchSpc->monitoringSymbolsWithinSlot)
6402                {
6403                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6404                   {
6405                      if(searchSpc->nrofCandidates)
6406                      {
6407                         if(searchSpc->searchSpaceType)
6408                         {
6409                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
6410                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
6411                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
6412                                     SearchSpace__searchSpaceType));
6413                         }
6414                         DU_FREE(searchSpc->nrofCandidates,
6415                               sizeof(struct SearchSpace__nrofCandidates));
6416                      }
6417                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
6418                            searchSpc->monitoringSymbolsWithinSlot->size);
6419                   }
6420                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
6421                         sizeof(BIT_STRING_t));
6422                }
6423                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
6424                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
6425             }
6426             DU_FREE(searchSpc->controlResourceSetId,
6427                   sizeof(ControlResourceSetId_t));
6428          }
6429       }
6430       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
6431       {
6432          DU_FREE(searchSpcList->list.array[idx1],
6433                sizeof(struct SearchSpace));
6434       }
6435       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
6436    }
6437 }
6438 /*******************************************************************
6439  *
6440  * @brief Frees memory allocated for PdschTimeDomAllocList
6441  *
6442  * @details
6443  *
6444  *    Function : FreePdschTimeDomAllocList
6445  *
6446  *    Functionality: Deallocating memory of PdschTimeDomAllocList
6447  *
6448  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6449  *
6450  * @return void
6451  *
6452  * ****************************************************************/
6453 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6454 {
6455    uint8_t idx1=0;
6456
6457    if(timeDomAllocList->choice.setup)
6458    {
6459       if(timeDomAllocList->choice.setup->list.array)
6460       {
6461          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
6462          {
6463             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
6464             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
6465                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
6466          }
6467          DU_FREE(timeDomAllocList->choice.setup->list.array, \
6468                timeDomAllocList->choice.setup->list.size);
6469       }
6470       DU_FREE(timeDomAllocList->choice.setup,\
6471             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
6472    }
6473 }
6474 /*******************************************************************
6475  *
6476  * @brief Frees memory allocated for PuschTimeDomAllocList
6477  *
6478  *@details
6479  *
6480  *    Function : FreePuschTimeDomAllocList
6481  *
6482  *    Functionality: Deallocating memory of PuschTimeDomAllocList
6483  *
6484  * @params[in] PUSCH_Config_t *puschCfg
6485  *
6486  * @return void
6487  *
6488  * ****************************************************************/
6489 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
6490 {
6491    uint8_t rsrcListIdx=0;
6492    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6493
6494    if(puschCfg->pusch_TimeDomainAllocationList)
6495    {
6496       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6497       if(timeDomAllocList_t->choice.setup)
6498       {
6499          if(timeDomAllocList_t->choice.setup->list.array)
6500          {
6501             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
6502             {
6503                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
6504                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
6505                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
6506             }
6507             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
6508                   timeDomAllocList_t->choice.setup->list.size);
6509          }
6510          DU_FREE(timeDomAllocList_t->choice.setup, \
6511                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
6512       }
6513       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
6514       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
6515             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
6516    }
6517
6518 }
6519
6520 /*******************************************************************
6521  *
6522  * @brief Frees memory allocated for Dedicated PUCCH config
6523  *
6524  * @details
6525  *
6526  *    Function : FreeBWPUlDedPucchCfg
6527  *
6528  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
6529  *
6530  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
6531  *
6532  * @return void
6533  *
6534  * ****************************************************************/
6535 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
6536 {
6537    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
6538    PUCCH_Config_t *pucchCfg = NULLP;
6539    PUCCH_ResourceSet_t *rsrcSet = NULLP;
6540    PUCCH_Resource_t *rsrc = NULLP;
6541
6542    if(ulBwpPucchCfg)
6543    {
6544       if(ulBwpPucchCfg->choice.setup)
6545       {
6546          pucchCfg = ulBwpPucchCfg->choice.setup;
6547
6548          //Free resource set list
6549          if(pucchCfg->resourceSetToAddModList)
6550          {
6551             if(pucchCfg->resourceSetToAddModList->list.array)
6552             {
6553                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
6554                {
6555                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
6556                   if(rsrcSet->resourceList.list.array)
6557                   {
6558                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
6559                      {
6560                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
6561                      }
6562                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
6563                   }
6564                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
6565                }
6566                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
6567             }
6568             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
6569          }
6570
6571          //Free resource list
6572          if(pucchCfg->resourceToAddModList)
6573          {
6574             if(pucchCfg->resourceToAddModList->list.array)
6575             {
6576                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
6577                {
6578                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
6579                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
6580                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
6581                }
6582                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
6583             }
6584             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
6585          }
6586
6587          //PUCCH Format 1
6588          if(pucchCfg->format1)
6589          {
6590             if(pucchCfg->format1->choice.setup)
6591             {
6592                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
6593                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
6594             }
6595             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
6596          }
6597
6598          //DL DATA TO UL ACK
6599          if(pucchCfg->dl_DataToUL_ACK)
6600          {
6601             if(pucchCfg->dl_DataToUL_ACK->list.array)
6602             {
6603                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
6604                {
6605                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
6606                }
6607                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
6608             }
6609             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
6610          }
6611
6612          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
6613       }
6614       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
6615    }
6616 }
6617
6618 /*******************************************************************
6619  *
6620  * @brief Frees memory allocated for InitialUlBWP
6621  *
6622  * @details
6623  *
6624  *    Function : FreeInitialUlBWP
6625  *
6626  *    Functionality: Deallocating memory of InitialUlBWP
6627  *
6628  * @params[in] BWP_UplinkDedicated_t *ulBwp
6629  *
6630  * @return void
6631  *
6632  * ****************************************************************/
6633 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
6634 {
6635    uint8_t  rSetIdx, rsrcIdx;
6636    SRS_Config_t   *srsCfg = NULLP;
6637    PUSCH_Config_t *puschCfg = NULLP;
6638    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6639    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6640    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6641    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6642
6643    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
6644
6645    if(ulBwp->pusch_Config)
6646    {
6647       if(ulBwp->pusch_Config->choice.setup)
6648       {
6649          puschCfg=ulBwp->pusch_Config->choice.setup;
6650          if(puschCfg->dataScramblingIdentityPUSCH)
6651          {
6652             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6653             {
6654                FreePuschTimeDomAllocList(puschCfg);
6655                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6656                if(dmrsUlCfg->choice.setup)
6657                {
6658                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6659                   {
6660                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6661                      {
6662                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
6663                               sizeof(long));
6664                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
6665                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
6666                      }
6667                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
6668                            sizeof(long));
6669                   }
6670                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
6671                }
6672                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
6673                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
6674             }
6675             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
6676          }
6677          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
6678       }
6679       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
6680
6681       /* Free SRS-Config */
6682       if(ulBwp->srs_Config)
6683       {
6684          if(ulBwp->srs_Config->choice.setup)
6685          {
6686             srsCfg = ulBwp->srs_Config->choice.setup;
6687
6688             /* Free Resource Set to add/mod list */
6689             if(srsCfg->srs_ResourceSetToAddModList)
6690             {
6691                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6692                if(rsrcSetList->list.array)
6693                {
6694                   rSetIdx = 0;
6695
6696                   /* Free SRS resource Id list in this SRS resource set */
6697                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6698                   {
6699                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6700
6701                      if(rsrcIdList->list.array)
6702                      {
6703                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
6704                         {
6705                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
6706                         }
6707                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
6708                      }
6709                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
6710                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
6711                   }
6712
6713                   /* Free resource type info for this SRS resource set */
6714                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
6715                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
6716
6717                   /* Free memory for each resource set */
6718                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6719                   {
6720                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
6721                   }
6722                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
6723                }
6724                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
6725                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
6726             }
6727
6728             /* Free resource to add/modd list */
6729             if(srsCfg->srs_ResourceToAddModList)
6730             {
6731                resourceList = srsCfg->srs_ResourceToAddModList;
6732                if(resourceList->list.array)
6733                {
6734                   rsrcIdx = 0;
6735                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
6736                         sizeof(struct SRS_Resource__transmissionComb__n2));
6737                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
6738                         sizeof(struct SRS_Resource__resourceType__aperiodic));
6739
6740                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6741                   {
6742                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
6743                   }
6744                   DU_FREE(resourceList->list.array, resourceList->list.size);
6745                }
6746                DU_FREE(srsCfg->srs_ResourceToAddModList, \
6747                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
6748             }
6749
6750             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
6751          }
6752          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
6753       }
6754    }
6755 }
6756 /*******************************************************************
6757  *
6758  * @brief Frees memory allocated for initialUplinkBWP
6759  *
6760  * @details
6761  *
6762  *    Function : FreeinitialUplinkBWP
6763  *
6764  *    Functionality: Deallocating memory of initialUplinkBWP
6765  *
6766  * @params[in] UplinkConfig_t *ulCfg
6767  *
6768  * @return void
6769  *
6770  *
6771  * ****************************************************************/
6772 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
6773 {
6774    BWP_UplinkDedicated_t *ulBwp=NULLP;
6775    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6776
6777    if(ulCfg->initialUplinkBWP)
6778    {
6779       ulBwp=ulCfg->initialUplinkBWP;
6780       if(ulCfg->firstActiveUplinkBWP_Id)
6781       {
6782          if(ulCfg->pusch_ServingCellConfig)
6783          {
6784             puschCfg=ulCfg->pusch_ServingCellConfig;
6785             if(puschCfg->choice.setup)
6786             {
6787                if(puschCfg->choice.setup->ext1)
6788                {
6789                   DU_FREE(puschCfg->choice.setup->ext1->\
6790                         processingType2Enabled,sizeof(BOOLEAN_t));
6791                   DU_FREE(puschCfg->choice.setup->ext1->\
6792                         maxMIMO_Layers,sizeof(long));
6793                   DU_FREE(puschCfg->choice.setup->ext1, \
6794                         sizeof(struct PUSCH_ServingCellConfig__ext1));
6795                }
6796                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
6797             }
6798             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
6799          }
6800          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
6801       }
6802       FreeInitialUlBWP(ulBwp);
6803       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
6804    }
6805 }
6806 /*******************************************************************
6807  *
6808  * @brief Frees emmory allocated for BWPDlDedPdschCfg
6809  *
6810  * @details
6811  *
6812  *    Function : FreeBWPDlDedPdschCfg
6813  *
6814  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
6815  *
6816  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6817  *
6818  * @return void
6819  *
6820  *
6821  * ****************************************************************/
6822 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
6823 {
6824    struct PDSCH_Config *pdschCfg=NULLP;
6825    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6826    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6827    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6828
6829    if(dlBwp->pdsch_Config->choice.setup)
6830    {
6831       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6832       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6833       {
6834          if(pdschCfg->pdsch_TimeDomainAllocationList)
6835          {
6836             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6837             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6838             {
6839                prbBndlType=&pdschCfg->prb_BundlingType;
6840                DU_FREE(prbBndlType->choice.staticBundling,\
6841                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
6842                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
6843             }
6844             FreePdschTimeDomAllocList(timeDomAllocList);
6845             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
6846                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
6847          }
6848          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6849          if(dmrsDlCfg->choice.setup)
6850          {
6851             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
6852                   sizeof(long));
6853             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
6854          }
6855          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
6856                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6857       }
6858       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6859    }
6860 }
6861 /*******************************************************************
6862  *
6863  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6864  *
6865  * @details
6866  *
6867  *    Function : FreeBWPDlDedPdcchCfg
6868  *
6869  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6870  *
6871  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6872  *
6873  * @return void
6874  *
6875  *
6876  * ****************************************************************/
6877 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6878 {
6879    uint8_t idx1=0;
6880    uint8_t idx2=0;
6881    struct PDCCH_Config *pdcchCfg=NULLP;
6882    struct ControlResourceSet *controlRSet=NULLP;
6883    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6884
6885    if(dlBwp->pdcch_Config->choice.setup)
6886    {
6887       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6888       if(pdcchCfg->controlResourceSetToAddModList)
6889       {
6890          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6891          if(controlRSetList->list.array)
6892          {
6893             controlRSet = controlRSetList->list.array[idx2];
6894             if(controlRSet)
6895             {
6896                if(controlRSet->frequencyDomainResources.buf)
6897                {
6898                   if(controlRSet->pdcch_DMRS_ScramblingID)
6899                   {
6900                      if(pdcchCfg->searchSpacesToAddModList)
6901                      {
6902                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6903                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
6904                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6905                      }
6906                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6907                   }
6908                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
6909                         controlRSet->frequencyDomainResources.size);
6910                }
6911             }
6912             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6913             {
6914                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6915             }
6916             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6917          }
6918          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6919                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6920       }
6921       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6922    }
6923 }
6924
6925 /*******************************************************************
6926  *
6927  * @brief Frees emmory allocated for DUToCURRCContainer
6928  *
6929  * @details
6930  *
6931  *    Function : FreeMemDuToCuRrcCont
6932  *
6933  *    Functionality: Deallocating memory of DuToCuRrcContainer
6934  *
6935  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
6936  *
6937  * @return ROK     - success
6938  *         RFAILED - failure
6939  *
6940  * ****************************************************************/
6941 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
6942 {
6943    uint8_t idx=0;
6944    SpCellConfig_t *spCellCfg=NULLP;
6945    ServingCellConfig_t *srvCellCfg=NULLP;
6946    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6947    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6948    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6949    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6950    struct RLC_Config *rlcConfig=NULLP;
6951    struct LogicalChannelConfig *macLcConfig=NULLP;
6952    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6953    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6954    struct TAG_Config *tagConfig=NULLP;
6955    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6956    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6957    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6958
6959    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6960    if(rlcBearerList)
6961    {
6962       if(rlcBearerList->list.array)
6963       {
6964          for(idx=0; idx<rlcBearerList->list.count; idx++)
6965          {
6966             if(rlcBearerList->list.array[idx])
6967             {
6968                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6969                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6970                if(rlcConfig)
6971                {
6972                   if(rlcConfig->choice.am)
6973                   {
6974                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6975                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6976                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6977                   }
6978                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
6979                }
6980                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6981                if(macLcConfig)
6982                {
6983                   if(macLcConfig->ul_SpecificParameters)
6984                   {
6985                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6986                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6987                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6988                   }
6989                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6990                }
6991                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6992             }
6993          }
6994          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6995       }
6996       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6997    }
6998
6999    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
7000    if(macCellGrpCfg)
7001    {
7002       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
7003       if(schedulingRequestConfig)
7004       {
7005          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
7006          if(schReqList)
7007          {
7008             if(schReqList->list.array)
7009             {
7010                for(idx=0;idx<schReqList->list.count; idx++)
7011                {
7012                   if(schReqList->list.array[idx])
7013                   {
7014                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
7015                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
7016                   }
7017                }
7018                DU_FREE(schReqList->list.array, schReqList->list.size);
7019             }
7020             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
7021                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
7022             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
7023       }
7024       if(macCellGrpCfg->bsr_Config)
7025       {
7026          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
7027       }
7028       tagConfig = macCellGrpCfg->tag_Config;
7029       if(tagConfig)
7030       {
7031          tagList = tagConfig->tag_ToAddModList;
7032          if(tagList)
7033          {
7034             if(tagList->list.array)
7035             {
7036                for(idx=0; idx<tagList->list.count; idx++)
7037                {
7038                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
7039                }
7040                DU_FREE(tagList->list.array, tagList->list.size);
7041             }
7042             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
7043          }
7044          DU_FREE(tagConfig, sizeof(struct TAG_Config));
7045       }
7046
7047       phrConfig = macCellGrpCfg->phr_Config;
7048       if(phrConfig)
7049       {
7050          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
7051          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
7052       }
7053
7054       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
7055    }
7056
7057    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7058    if(phyCellGrpCfg)
7059    {
7060       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
7061       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
7062    }
7063
7064    spCellCfg = cellGrpCfg->spCellConfig;
7065    if(spCellCfg)
7066    {
7067       if(spCellCfg->servCellIndex)
7068       {
7069          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7070          {
7071             if(spCellCfg->spCellConfigDedicated)
7072             {
7073                srvCellCfg = spCellCfg->spCellConfigDedicated;
7074                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
7075                {
7076                   if(srvCellCfg->initialDownlinkBWP)
7077                   {
7078                      dlBwp = srvCellCfg->initialDownlinkBWP;
7079                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7080                      {
7081                         if(srvCellCfg->defaultDownlinkBWP_Id)
7082                         {
7083                            if(srvCellCfg->uplinkConfig)
7084                            {
7085                               if(srvCellCfg->pdsch_ServingCellConfig)
7086                               {
7087                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
7088                                  if(pdschCfg->choice.setup)
7089                                  {
7090                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
7091                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
7092                                  }
7093                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
7094                                           ServingCellConfig__pdsch_ServingCellConfig));
7095                               }
7096                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
7097                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
7098                            }
7099                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
7100                         }
7101                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
7102                      }
7103                      if(dlBwp->pdcch_Config)
7104                      {
7105                         if(dlBwp->pdsch_Config)
7106                         {
7107                            FreeBWPDlDedPdschCfg(dlBwp);
7108                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
7109                         }
7110                         FreeBWPDlDedPdcchCfg(dlBwp);
7111                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
7112                      }
7113                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
7114                   }
7115                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
7116                }
7117                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
7118             }
7119             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
7120          }
7121          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
7122       }
7123       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
7124    }
7125    return ROK;
7126 }
7127
7128 /*******************************************************************
7129  *
7130  * @brief Builds CellGroupConfigRrc for DU To CU RRC Container
7131  *
7132  * @details
7133  *
7134  *    Function : BuildCellGroupConfigRrc
7135  *
7136  *    Functionality: Builds and copied Cell group config buffer into
7137  *       DuToCuRrcContainer
7138  *
7139  * @params[in] idx, index in F1AP msg
7140  *             DuToCuRRCContainer, DuToCuRRCContainer
7141  *
7142  * @return ROK     - success
7143  *         RFAILED - failure
7144  *
7145  * ****************************************************************/
7146 uint8_t BuildCellGroupConfigRrc(DuUeCb *ueCb, OCTET_STRING_t *duToCuRrcContainer)
7147 {
7148    uint8_t  ret = ROK;
7149    CellGroupConfigRrc_t  cellGrpCfg;
7150    asn_enc_rval_t        encRetVal;
7151    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
7152    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
7153
7154    while(true)
7155    {
7156       cellGrpCfg.cellGroupId = CELL_GRP_ID;
7157
7158       cellGrpCfg.rlc_BearerToAddModList = NULLP;
7159       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
7160       if(!cellGrpCfg.rlc_BearerToAddModList)
7161       {
7162          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7163          ret = RFAILED;
7164          break;
7165       }
7166       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList) != ROK)
7167       {
7168          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
7169          ret = RFAILED;
7170          break;
7171       }
7172
7173       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
7174       cellGrpCfg.mac_CellGroupConfig = NULLP;
7175       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
7176       if(!cellGrpCfg.mac_CellGroupConfig)
7177       {
7178          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7179          ret = RFAILED;
7180          break;
7181       }
7182       if(BuildMacCellGrpCfg(ueCb, cellGrpCfg.mac_CellGroupConfig) != ROK)
7183       {
7184          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
7185          ret = RFAILED;
7186          break;
7187       }
7188
7189       cellGrpCfg.physicalCellGroupConfig = NULLP;
7190       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
7191       if(!cellGrpCfg.physicalCellGroupConfig)
7192       {
7193          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7194          ret = RFAILED;
7195          break;
7196       }
7197       if(BuildPhyCellGrpCfg(ueCb, cellGrpCfg.physicalCellGroupConfig) != ROK)
7198       {
7199          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
7200          ret = RFAILED;
7201          break;
7202       }
7203
7204       cellGrpCfg.spCellConfig = NULLP;
7205       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
7206       if(!cellGrpCfg.spCellConfig)
7207       {
7208          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7209          ret = RFAILED;
7210          break;
7211       }
7212       if(BuildSpCellCfg(ueCb, cellGrpCfg.spCellConfig) != ROK)
7213       {
7214          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
7215          ret = RFAILED;
7216          break;
7217       }
7218
7219       cellGrpCfg.sCellToAddModList = NULLP;
7220       cellGrpCfg.sCellToReleaseList = NULLP;
7221       cellGrpCfg.ext1 = NULLP;
7222
7223       /* encode cellGrpCfg into duToCuRrcContainer */
7224       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
7225       memset(encBuf, 0, ENC_BUF_MAX_LEN);
7226       encBufSize = 0;
7227       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
7228       /* Encode results */
7229       if(encRetVal.encoded == ENCODE_FAIL)
7230       {
7231          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
7232                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7233          ret = RFAILED;
7234          break;
7235       }
7236       else
7237       {
7238          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
7239          for(int i=0; i< encBufSize; i++)
7240          {
7241             printf("%x",encBuf[i]);
7242          }
7243       }
7244
7245       duToCuRrcContainer->size = encBufSize;
7246       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
7247       if(!duToCuRrcContainer->buf)
7248       {
7249          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
7250          ret = RFAILED;
7251          break;
7252       }
7253       if(ret == ROK)
7254       {
7255          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
7256       }
7257       break;
7258    }
7259    FreeMemDuToCuRrcCont(&cellGrpCfg);
7260    return ret;
7261 }
7262
7263 /*******************************************************************
7264  *
7265  * @brief Free memory allocated in InitialULRRCMessage
7266  *
7267  * @details
7268  *
7269  *    Function : freeInitUlRrcMsgTransfer
7270  *
7271  *    Functionality: Free memory allocated in InitialULRRCMessage
7272  *
7273  * @params[in]F1AP_PDU_t  *f1apMsg)
7274  *
7275  * @return ROK     - success
7276  *         RFAILED - failure
7277  *
7278  * ****************************************************************/
7279
7280 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
7281 {
7282    uint8_t ieIdx, arrIdx;
7283    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
7284
7285    if(f1apMsg)
7286    {
7287       if(f1apMsg->choice.initiatingMessage)
7288       {
7289          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
7290             choice.InitialULRRCMessageTransfer;
7291          if(initULRRCMsg->protocolIEs.list.array)
7292          {
7293             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
7294             {
7295                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
7296                {
7297                   case ProtocolIE_ID_id_NRCGI:
7298                   {
7299                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
7300                      {
7301                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
7302                         {
7303                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
7304                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
7305                         }
7306                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
7307                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
7308                      }
7309                      break;
7310                   }
7311                   case ProtocolIE_ID_id_RRCContainer:
7312                   {
7313                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
7314                      {
7315                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
7316                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
7317                      }
7318                      break;
7319                   }
7320                   case ProtocolIE_ID_id_DUtoCURRCContainer:
7321                   {
7322                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
7323                      {
7324                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
7325                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
7326                      }
7327                      break;
7328                   }
7329                   default:
7330                      break;
7331                }
7332              }
7333              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
7334              {
7335                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
7336                 {
7337                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
7338                       sizeof(InitialULRRCMessageTransferIEs_t));
7339                 }
7340              }
7341              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
7342           }
7343          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
7344       }
7345       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
7346    }
7347    else
7348    {
7349       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
7350       return RFAILED;
7351    }
7352    return ROK;
7353 }
7354
7355 /*******************************************************************
7356  *
7357  * @brief Builds and sends the InitialULRRCMessage
7358  *
7359  * @details
7360  *
7361  *    Function : BuildAndSendInitialRrcMsgTransfer
7362  *
7363  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
7364  *                   it to the CU through SCTP.
7365  *
7366  * @params[in]
7367  *
7368  * @return ROK     - success
7369  *         RFAILED - failure
7370  *
7371  * ****************************************************************/
7372 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
7373       uint16_t rrcContSize, uint8_t *rrcContainer)
7374 {
7375    uint8_t   ret;
7376    uint8_t   elementCnt;
7377    uint8_t   ieIdx, cellIdx, ueIdx;
7378    DuUeCb    *duUeCb = NULLP;
7379    asn_enc_rval_t  encRetVal;
7380    F1AP_PDU_t  *f1apMsg = NULLP;
7381    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
7382    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
7383
7384    while(true)
7385    {
7386       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
7387       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
7388       if(f1apMsg == NULLP)
7389       {
7390          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
7391          break;
7392       }
7393       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
7394       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
7395       if(f1apMsg->choice.initiatingMessage == NULLP)
7396       {
7397          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
7398          break;
7399       }
7400       f1apMsg->choice.initiatingMessage->procedureCode =\
7401                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
7402       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
7403       f1apMsg->choice.initiatingMessage->value.present = \
7404                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
7405       initULRRCMsg =\
7406                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
7407       elementCnt = 5;
7408       initULRRCMsg->protocolIEs.list.count = elementCnt;
7409       initULRRCMsg->protocolIEs.list.size = \
7410                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
7411       /* Initialize the F1Setup members */
7412       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
7413       if(initULRRCMsg->protocolIEs.list.array == NULLP)
7414       {
7415          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
7416                RRCSetupRequestMessageTransferIEs failed");
7417          break;
7418       }
7419       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
7420       {
7421          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
7422                sizeof(InitialULRRCMessageTransferIEs_t));
7423          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
7424          {
7425             break;
7426          }
7427       }
7428       ieIdx = 0;
7429       /*GNB DU UE F1AP ID*/
7430       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7431                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
7432       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
7433       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
7434                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
7435       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
7436
7437
7438       /*NRCGI*/
7439       ieIdx++;
7440       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7441                                                         ProtocolIE_ID_id_NRCGI;
7442       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
7443       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
7444                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
7445
7446       ret =\
7447            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
7448       if(ret!=ROK)
7449       {
7450          break;
7451       }
7452
7453       /*CRNTI*/
7454       ieIdx++;
7455       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7456                                                         ProtocolIE_ID_id_C_RNTI;
7457       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7458       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
7459                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
7460       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
7461
7462       /*RRCContainer*/
7463       ieIdx++;
7464       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7465                                                         ProtocolIE_ID_id_RRCContainer;
7466       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7467       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
7468                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
7469
7470       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
7471       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
7472             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
7473       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
7474       {
7475          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
7476          break;
7477
7478       }
7479       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
7480             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
7481
7482
7483       /*DUtoCURRCContainer*/
7484       ieIdx++;
7485       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
7486       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7487       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
7488                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
7489
7490       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
7491       {
7492          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
7493          {
7494             if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
7495                   (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti == crnti))
7496             {
7497                duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
7498             }
7499          }
7500       }
7501
7502       ret = BuildCellGroupConfigRrc(duUeCb, &initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
7503       if(ret != ROK)
7504       {
7505          break;
7506       }
7507
7508       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
7509
7510       /* Encode the Intial UL RRC Message transfer as APER */
7511       memset(encBuf, 0, ENC_BUF_MAX_LEN);
7512       encBufSize = 0;
7513       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
7514       /* Encode results */
7515       if(encRetVal.encoded == ENCODE_FAIL)
7516       {
7517          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
7518                structure (at %s)\n",encRetVal.failed_type ? \
7519                encRetVal.failed_type->name : "unknown");
7520          ret = RFAILED;
7521          break;
7522       }
7523       else
7524       {
7525
7526          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
7527                Message transfer\n");
7528          for(int i=0; i< encBufSize; i++)
7529          {
7530             printf("%x",encBuf[i]);
7531          }
7532       }
7533       /* Sending  msg  */
7534       if(sendF1APMsg() != ROK)
7535       {
7536          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
7537          ret = RFAILED;
7538          break;
7539       }
7540       break;
7541    }
7542    freeInitUlRrcMsgTransfer(f1apMsg);
7543    return ret;
7544 }/* End of BuildAndSendInitialRrcMsgTransfer*/
7545
7546 /*****  UE SETUP REQUEST *****/
7547
7548 /*******************************************************************
7549  *
7550  * @brief Free Qos And Snssai Drb Info
7551  *
7552  * @details
7553  *
7554  *    Function : freeDrbQosAndSnssaiInfo
7555  *
7556  *    Functionality: Free Qos And Snssai Drb Info
7557  *
7558  * @params[in] LcCfg *lcCfg,
7559  * @return void
7560  *
7561  * ****************************************************************/
7562 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
7563 {
7564    if(lcCfg->snssai)
7565    {
7566       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
7567    }
7568    if(lcCfg->drbQos)
7569    {
7570       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
7571    }
7572 }
7573
7574 /******************************************************************
7575 *
7576 * @brief Function to delete the RLC Lc cfg from UE APP DB
7577 *
7578 * @details
7579 *
7580 *  Function : freeRlcLcCfg
7581 *
7582 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
7583 *
7584 *
7585  *****************************************************************/
7586
7587 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
7588 {
7589    switch(lcCfg->rlcMode)
7590    {
7591       case RLC_AM :
7592          {
7593             if(lcCfg->u.amCfg)
7594             {
7595                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
7596             }
7597             break;
7598          }
7599       case RLC_UM_BI_DIRECTIONAL :
7600          {
7601             if(lcCfg->u.umBiDirCfg)
7602             {
7603                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7604             }
7605             break;
7606          }
7607       case RLC_UM_UNI_DIRECTIONAL_UL :
7608          {
7609             if(lcCfg->u.umUniDirUlCfg)
7610             {
7611                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7612             }
7613             break;
7614
7615          }
7616       case RLC_UM_UNI_DIRECTIONAL_DL :
7617          {
7618             if(lcCfg->u.umUniDirDlCfg)
7619             {
7620                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7621             }
7622             break;
7623          }
7624       default:
7625          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
7626          break;
7627    }
7628    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
7629 }
7630
7631 /*******************************************************************
7632  *
7633  * @brief Function to free MacLcCfg
7634  *
7635  * @details
7636  *
7637  *    Function : freeMacLcCfg
7638  *
7639  *    Functionality: Function to free MacLcCfg
7640  *
7641  * @params[in] LcCfg *lcCfg,
7642  * @return void
7643  *
7644  * ****************************************************************/
7645
7646 void  freeMacLcCfg(LcCfg *lcCfg)
7647 {
7648     /* Deleting DRBQOS */
7649    if(lcCfg->drbQos)
7650    {
7651       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
7652    }
7653    /* Deleting SNSSAI */
7654    if(lcCfg->snssai)
7655    {
7656       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
7657    }
7658 }
7659 /*******************************************************************
7660  *
7661  * @brief Free UE NR Capability received in UE Context setup request
7662  *
7663  * @details
7664  *
7665  *    Function : freeAperDecodeUeNrCapability
7666  *
7667  *    Functionality:
7668  *       Free UE NR Capability received in UE Context setup request
7669  *
7670  * @params[in]
7671  * @return ROK     - success
7672  *         RFAILED - failure
7673  *
7674  * ****************************************************************/
7675 void freeAperDecodeUeNrCapability(void *ueNrCapability)
7676 {
7677    uint8_t arrIdx =0;
7678    FeatureSets_t *featureSets =NULLP;
7679    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
7680
7681    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
7682    {
7683       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
7684       {
7685          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
7686             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
7687       }
7688       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
7689    }
7690
7691    if(ueNrCap->featureSets)
7692    {
7693       featureSets = ueNrCap->featureSets;
7694       if(featureSets->featureSetsDownlinkPerCC)
7695       {
7696          if(featureSets->featureSetsDownlinkPerCC->list.array)
7697          {
7698             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
7699             {
7700                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
7701                {
7702                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
7703                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
7704                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
7705                }
7706             }
7707             free(featureSets->featureSetsDownlinkPerCC->list.array);
7708          }
7709          free(featureSets->featureSetsDownlinkPerCC);
7710       }
7711       if(featureSets->featureSetsUplinkPerCC)
7712       {
7713          if(featureSets->featureSetsUplinkPerCC->list.array)
7714          {
7715             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
7716             {
7717                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
7718                {
7719                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
7720                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
7721                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
7722                }
7723             }
7724             free(featureSets->featureSetsUplinkPerCC->list.array);
7725          }
7726          free(featureSets->featureSetsUplinkPerCC);
7727       }
7728       free(ueNrCap->featureSets);
7729    }
7730 }
7731
7732 /*******************************************************************
7733 *
7734 * @brief Function to free PdcchSearchSpcToAddModList
7735          where memory allocated by aper_decoder
7736 *
7737 * @details
7738 *
7739 *    Function : freeAperDecodePdcchSearchSpcToAddModList
7740 *
7741 *    Functionality: Function to free PdcchSearchSpcToAddModList
7742 *
7743 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
7744 * @return void
7745 *
7746 * ****************************************************************/
7747
7748 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
7749 {
7750    uint8_t searchSpcArrIdx=0;
7751    uint8_t searchSpcArrIdx1=0;
7752    struct  SearchSpace *searchSpc=NULLP;
7753
7754
7755    if(searchSpcList->list.array)
7756    {
7757       if(searchSpcList->list.array[searchSpcArrIdx1])
7758       {
7759          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
7760          if(searchSpc->controlResourceSetId)
7761          {
7762             if(searchSpc->monitoringSlotPeriodicityAndOffset)
7763             {
7764                if(searchSpc->monitoringSymbolsWithinSlot)
7765                {
7766                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
7767                   {
7768                      if(searchSpc->nrofCandidates)
7769                      {
7770                         if(searchSpc->searchSpaceType)
7771                         {
7772                            free(searchSpc->searchSpaceType->choice.ue_Specific);
7773                            free(searchSpc->searchSpaceType);
7774                         }
7775                         free(searchSpc->nrofCandidates);
7776                      }
7777                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
7778                   }
7779                   free(searchSpc->monitoringSymbolsWithinSlot);
7780                }
7781                free(searchSpc->monitoringSlotPeriodicityAndOffset);
7782             }
7783             free(searchSpc->controlResourceSetId);
7784          }
7785       }
7786       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
7787       {
7788          free(searchSpcList->list.array[searchSpcArrIdx]);
7789       }
7790       free(searchSpcList->list.array);
7791    }
7792 }
7793 /*******************************************************************
7794 *
7795 * @brief Function for free part for the memory allocated by aper_decoder
7796 *
7797 * @details
7798 *
7799 *    Function : freeAperDecodeBWPDlDedPdcchConfig
7800 *
7801 *    Functionality: Function to free BWPDlDedPdcchConfig
7802 *
7803 * @params[in]
7804 * @return void
7805 *
7806 * ****************************************************************/
7807
7808
7809 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
7810 {
7811    uint8_t arrIdx1=0;
7812    uint8_t arrIdx2=0;
7813    struct PDCCH_Config *pdcchCfg=NULLP;
7814    struct ControlResourceSet *controlRSet=NULLP;
7815    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
7816
7817    if(dlBwp->pdcch_Config->choice.setup)
7818    {
7819       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
7820       if(pdcchCfg->controlResourceSetToAddModList)
7821       {
7822          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
7823          if(controlRSetList->list.array)
7824          {
7825             controlRSet = controlRSetList->list.array[arrIdx2];
7826             if(controlRSet)
7827             {
7828                if(controlRSet->frequencyDomainResources.buf)
7829                {
7830                   if(controlRSet->pdcch_DMRS_ScramblingID)
7831                   {
7832                      if(pdcchCfg->searchSpacesToAddModList)
7833                      {
7834                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
7835                         free(pdcchCfg->searchSpacesToAddModList);
7836                      }
7837                      free(controlRSet->pdcch_DMRS_ScramblingID);
7838                   }
7839                   free(controlRSet->frequencyDomainResources.buf);
7840                }
7841             }
7842             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
7843             {
7844                free(controlRSetList->list.array[arrIdx1]);
7845             }
7846             free(controlRSetList->list.array);
7847          }
7848          free(pdcchCfg->controlResourceSetToAddModList);
7849       }
7850       free(dlBwp->pdcch_Config->choice.setup);
7851    }
7852 }
7853 /*******************************************************************
7854 *
7855 * @brief Function to free PdschTimeDomAllocationList
7856 *     where the memory allocated by aper_decoder
7857 *
7858 * @details
7859 *
7860 *    Function : freeAperDecodePdschTimeDomAllocationList
7861 *
7862 *    Functionality: Function to free PdschTimeDomAllocationList
7863 *
7864 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
7865 * @return void
7866 *
7867 * ****************************************************************/
7868
7869
7870 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
7871 {
7872    uint8_t arrIdx=0;
7873
7874    if(timeDomAllocList->choice.setup)
7875    {
7876       if(timeDomAllocList->choice.setup->list.array)
7877       {
7878          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
7879          {
7880             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
7881          }
7882          free(timeDomAllocList->choice.setup->list.array);
7883       }
7884       free(timeDomAllocList->choice.setup);
7885    }
7886 }
7887
7888 /*******************************************************************
7889 *
7890 * @brief Function to free BWPDlDedPdschConfig
7891 *        where the memory allocated by aper_decoder
7892 *
7893 * @details
7894 *
7895 *    Function : freeAperDecodeBWPDlDedPdschConfig
7896 *
7897 *    Functionality: Function to free BWPDlDedPdschConfig
7898 *
7899 * @params[in] BWP_DownlinkDedicated_t *dlBwp
7900 * @return void
7901 *
7902 * ****************************************************************/
7903
7904
7905 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
7906 {
7907    struct PDSCH_Config *pdschCfg=NULLP;
7908    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
7909    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
7910    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
7911
7912    if(dlBwp->pdsch_Config->choice.setup)
7913    {
7914       pdschCfg=dlBwp->pdsch_Config->choice.setup;
7915       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7916       {
7917          if(pdschCfg->pdsch_TimeDomainAllocationList)
7918          {
7919             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
7920             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
7921             {
7922                prbBndlType=&pdschCfg->prb_BundlingType;
7923                free(prbBndlType->choice.staticBundling);
7924                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
7925             }
7926             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
7927             free(pdschCfg->pdsch_TimeDomainAllocationList);
7928          }
7929          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
7930          if(dmrsDlCfg->choice.setup)
7931          {
7932             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
7933             free(dmrsDlCfg->choice.setup);
7934          }
7935          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
7936       }
7937       free(dlBwp->pdsch_Config->choice.setup);
7938    }
7939 }
7940 /*******************************************************************
7941 *
7942 * @brief Function to free PuschTimeDomAllocListCfg
7943                  where the memory allocated by aper_decoder
7944 *
7945 * @details
7946 *
7947 *    Function : freeAperDecodePuschTimeDomAllocListCfg
7948 *
7949 *    Functionality: Function to free PuschTimeDomAllocListCfg
7950 *
7951 * @params[in] PUSCH_Config_t *puschCfg
7952 * @return void
7953 *
7954 * ****************************************************************/
7955
7956
7957 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
7958 {
7959    uint8_t arrIdx=0;
7960    uint8_t arrIdx1=0;
7961    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7962
7963    if(puschCfg->pusch_TimeDomainAllocationList)
7964    {
7965       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7966       if(timeDomAllocList_t->choice.setup)
7967       {
7968          if(timeDomAllocList_t->choice.setup->list.array)
7969          {
7970             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
7971             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
7972             {
7973                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
7974             }
7975             free(timeDomAllocList_t->choice.setup->list.array);
7976          }
7977          free(timeDomAllocList_t->choice.setup);
7978       }
7979       free(puschCfg->transformPrecoder);
7980       free(puschCfg->pusch_TimeDomainAllocationList);
7981    }
7982 }
7983 /*******************************************************************
7984 *
7985 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
7986 *
7987 * @details
7988 *
7989 *    Function : freeAperDecodeInitialUlBWPConfig
7990 *
7991 *    Functionality: Function to free InitialUlBWPConfig
7992 *
7993 * @params[in]  BWP_UplinkDedicated_t *ulBwp
7994 * @return void
7995 *
7996 * ****************************************************************/
7997
7998
7999 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
8000 {
8001    uint8_t  rSetIdx =0;
8002    uint8_t  rsrcIdx =0;
8003    SRS_Config_t   *srsCfg = NULLP;
8004    PUSCH_Config_t *puschCfg = NULLP;
8005    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
8006    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
8007    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
8008    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
8009
8010    if(ulBwp->pusch_Config)
8011    {
8012       if(ulBwp->pusch_Config->choice.setup)
8013       {
8014          puschCfg=ulBwp->pusch_Config->choice.setup;
8015          if(puschCfg->dataScramblingIdentityPUSCH)
8016          {
8017             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
8018             {
8019                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
8020                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
8021                if(dmrsUlCfg->choice.setup)
8022                {
8023                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
8024                   {
8025                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
8026                      {
8027                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
8028                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
8029                      }
8030                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
8031                   }
8032                   free(dmrsUlCfg->choice.setup);
8033                }
8034                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
8035             }
8036             free(puschCfg->dataScramblingIdentityPUSCH);
8037          }
8038          free(ulBwp->pusch_Config->choice.setup);
8039       }
8040       free(ulBwp->pusch_Config);
8041
8042       /* Free SRS-Config */
8043       if(ulBwp->srs_Config)
8044       {
8045          if(ulBwp->srs_Config->choice.setup)
8046          {
8047             srsCfg = ulBwp->srs_Config->choice.setup;
8048
8049             /* Free Resource Set to add/mod list */
8050             if(srsCfg->srs_ResourceSetToAddModList)
8051             {
8052                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
8053                if(rsrcSetList->list.array)
8054                {
8055                   rSetIdx = 0;
8056
8057                   /* Free SRS resource Id list in this SRS resource set */
8058                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
8059                   {
8060                      rsrcIdList =
8061                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
8062
8063                      if(rsrcIdList->list.array)
8064                      {
8065                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
8066                               rsrcIdx++)
8067                         {
8068                            free(rsrcIdList->list.array[rsrcIdx]);
8069                         }
8070                         free(rsrcIdList->list.array);
8071                      }
8072                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
8073                   }
8074
8075                   /* Free resource type info for this SRS resource set */
8076
8077                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
8078
8079                   /* Free memory for each resource set */
8080                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
8081                   {
8082                      free(rsrcSetList->list.array[rSetIdx]);
8083                   }
8084                   free(rsrcSetList->list.array);
8085                }
8086                free(srsCfg->srs_ResourceSetToAddModList);
8087             }
8088
8089             /* Free resource to add/modd list */
8090             if(srsCfg->srs_ResourceToAddModList)
8091             {
8092                resourceList = srsCfg->srs_ResourceToAddModList;
8093                if(resourceList->list.array)
8094                {
8095                   rsrcIdx = 0;
8096
8097                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
8098                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
8099
8100                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
8101                   {
8102                      free(resourceList->list.array[rsrcIdx]);
8103                   }
8104                   free(resourceList->list.array);
8105                }
8106                free(srsCfg->srs_ResourceToAddModList);
8107             }
8108
8109             free(ulBwp->srs_Config->choice.setup);
8110          }
8111          free(ulBwp->srs_Config);
8112       }
8113    }
8114 }
8115 /*******************************************************************
8116 *
8117 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
8118 *
8119 * @details
8120 *
8121 *    Function : freeAperDecodeinitialUplinkBWPConfig
8122 *
8123 *    Functionality: Function to free initialUplinkBWPConfig
8124 *
8125 * @params[in] UplinkConfig_t *ulCfg
8126 * @return void
8127 *
8128 * ****************************************************************/
8129
8130
8131 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
8132 {
8133    BWP_UplinkDedicated_t *ulBwp=NULLP;
8134    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
8135
8136    if(ulCfg->initialUplinkBWP)
8137    {
8138       ulBwp=ulCfg->initialUplinkBWP;
8139       if(ulCfg->firstActiveUplinkBWP_Id)
8140       {
8141          if(ulCfg->pusch_ServingCellConfig)
8142          {
8143             puschCfg=ulCfg->pusch_ServingCellConfig;
8144             if(puschCfg->choice.setup)
8145             {
8146                if(puschCfg->choice.setup->ext1)
8147                {
8148                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
8149                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
8150                   free(puschCfg->choice.setup->ext1);
8151                }
8152                free(puschCfg->choice.setup);
8153             }
8154             free(ulCfg->pusch_ServingCellConfig);
8155          }
8156          free(ulCfg->firstActiveUplinkBWP_Id);
8157       }
8158       freeAperDecodeInitialUlBWPConfig(ulBwp);
8159       free(ulCfg->initialUplinkBWP);
8160    }
8161 }
8162
8163 /*******************************************************************
8164  *
8165  * @brief Function to free DuUeCfg
8166  *
8167  * @details
8168  *
8169  *    Function : freeDuUeCfg
8170  *
8171  *    Functionality: Function to free DuUeCfg
8172  *
8173  * @params[in] DuUeCfg *ueCfg
8174  * @return void
8175  *
8176  * ****************************************************************/
8177 void freeDuUeCfg(DuUeCfg *ueCfg)
8178 {
8179    uint8_t lcIdx = 0;
8180    uint8_t arrIdx = 0;
8181    SpCellConfig_t *spCellCfg = NULLP;
8182    ServingCellConfig_t *srvCellCfg = NULLP;
8183    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8184    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
8185    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8186    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
8187    struct RLC_Config *rlcConfig = NULLP;
8188    struct LogicalChannelConfig *macLcConfig = NULLP;
8189    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
8190    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
8191    struct TAG_Config *tagConfig = NULLP;
8192    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
8193    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
8194    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
8195    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
8196
8197    if(ueCfg->ueNrCapability)
8198    {
8199       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
8200       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
8201       ueCfg->ueNrCapability = NULLP;
8202    }
8203
8204    if(ueCfg->cellGrpCfg)
8205    {
8206
8207       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
8208       if(rlcBearerList)
8209       {
8210          if(rlcBearerList->list.array)
8211          {
8212             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
8213             {
8214                if(rlcBearerList->list.array[arrIdx])
8215                {
8216                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
8217                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
8218
8219                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
8220                   {
8221                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
8222                   }
8223                   if(rlcConfig)
8224                   {
8225                      if(rlcConfig->choice.am)
8226                      {
8227                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
8228                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
8229                         free(rlcConfig->choice.am);
8230                      }
8231                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
8232                   }
8233                   if(macLcConfig)
8234                   {
8235                      if(macLcConfig->ul_SpecificParameters)
8236                      {
8237                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
8238                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
8239                         free(macLcConfig->ul_SpecificParameters);
8240                      }
8241                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
8242                   }
8243                   free(rlcBearerList->list.array[arrIdx]);
8244                }
8245             }
8246             free(rlcBearerList->list.array);
8247          }
8248          free(cellGrpCfg->rlc_BearerToAddModList);
8249       }
8250
8251       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
8252       if(macCellGrpCfg)
8253       {
8254          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
8255          if(schedulingRequestConfig)
8256          {
8257             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
8258             if(schReqList)
8259             {
8260                if(schReqList->list.array)
8261                {
8262                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
8263                   {
8264                      if(schReqList->list.array[arrIdx])
8265                      {
8266                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
8267                         free(schReqList->list.array[arrIdx]);
8268                      }
8269                   }
8270                   free(schReqList->list.array);
8271                }
8272                free(schedulingRequestConfig->schedulingRequestToAddModList);
8273             }
8274             free(macCellGrpCfg->schedulingRequestConfig);
8275          }
8276          if(macCellGrpCfg->bsr_Config)
8277          {
8278             free(macCellGrpCfg->bsr_Config);
8279          }
8280          tagConfig = macCellGrpCfg->tag_Config;
8281          if(tagConfig)
8282          {
8283             tagList = tagConfig->tag_ToAddModList;
8284             if(tagList)
8285             {
8286                if(tagList->list.array)
8287                {
8288                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
8289                   {
8290                      free(tagList->list.array[arrIdx]);
8291                   }
8292                   free(tagList->list.array);
8293                }
8294                free(tagConfig->tag_ToAddModList);
8295             }
8296             free(tagConfig);
8297          }
8298
8299          phrConfig = macCellGrpCfg->phr_Config;
8300          if(phrConfig)
8301          {
8302             free(phrConfig->choice.setup);
8303             free(phrConfig);
8304          }
8305
8306          free(macCellGrpCfg);
8307       }
8308
8309       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
8310       if(phyCellGrpCfg)
8311       {
8312          free(phyCellGrpCfg->p_NR_FR1);
8313          free(phyCellGrpCfg);
8314       }
8315
8316       spCellCfg = cellGrpCfg->spCellConfig;
8317       if(spCellCfg)
8318       {
8319          if(spCellCfg->servCellIndex)
8320          {
8321             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
8322             {
8323                if(spCellCfg->spCellConfigDedicated)
8324                {
8325                   srvCellCfg = spCellCfg->spCellConfigDedicated;
8326                   if(srvCellCfg->initialDownlinkBWP)
8327                   {
8328                      dlBwp = srvCellCfg->initialDownlinkBWP;
8329                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
8330                      {
8331                         if(srvCellCfg->defaultDownlinkBWP_Id)
8332                         {
8333                            if(srvCellCfg->uplinkConfig)
8334                            {
8335
8336                               if(srvCellCfg->pdsch_ServingCellConfig)
8337                               {
8338                                  pdschCfg=
8339                                     srvCellCfg->pdsch_ServingCellConfig;
8340                                  if(pdschCfg->choice.setup)
8341                                  {
8342
8343                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
8344                                     free(pdschCfg->choice.setup);
8345                                  }
8346
8347                                  free(srvCellCfg->pdsch_ServingCellConfig);
8348                               }
8349
8350                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
8351                               free(srvCellCfg->uplinkConfig);
8352                            }
8353                            free(srvCellCfg->defaultDownlinkBWP_Id);
8354                         }
8355
8356                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
8357                      }
8358                      if(dlBwp->pdcch_Config)
8359                      {
8360                         if(dlBwp->pdsch_Config)
8361                         {
8362                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
8363                            free(dlBwp->pdsch_Config);
8364                         }
8365                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
8366                         free(dlBwp->pdcch_Config);
8367                      }
8368                      free(srvCellCfg->initialDownlinkBWP);
8369                   }
8370
8371                   free(spCellCfg->spCellConfigDedicated);
8372                }
8373                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
8374             }
8375             free(spCellCfg->servCellIndex);
8376          }
8377          free(spCellCfg);
8378       }
8379       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
8380       ueCfg->cellGrpCfg = NULLP;
8381    }
8382    if(ueCfg->ambrCfg)
8383    {
8384       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
8385    }
8386    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
8387    {
8388       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
8389    }
8390    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
8391    {
8392       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
8393    }
8394    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
8395    {
8396       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
8397    }
8398 }
8399
8400 /*******************************************************************
8401  *
8402  * @brief Function to free UecontextSetupDb
8403  *
8404  * @details
8405  *
8406  *    Function : freeF1UeDb
8407  *
8408  *    Functionality: Function to free UecontextSetupDb
8409  *
8410  * @params[in] UecontextSetupDb *
8411  * @return void
8412  *
8413  * ****************************************************************/
8414
8415 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
8416 {
8417
8418    if(f1UeDb->dlRrcMsg)
8419    {
8420       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
8421       {
8422         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
8423                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
8424       }
8425       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
8426    }
8427    freeDuUeCfg(&f1UeDb->duUeCfg);
8428    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
8429    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
8430 }
8431
8432 /*******************************************************************
8433  *
8434  * @brief Function to build Am cfg Info
8435  *
8436  * @details
8437  *
8438  *    Function : extractRlcAmCfg
8439  *
8440  *    Functionality: Function to build Am cfg Info
8441  *
8442  * @params[in] AmBearerCfg *
8443  *             void *
8444  *
8445  * @return ROK/RFAILED
8446  *
8447  * ****************************************************************/
8448
8449 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
8450 {
8451    if(rlcAmCfg)
8452    {
8453       /* UL AM */
8454       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
8455       {
8456          amCfgToSet->ulAmCfg.snLenUl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->dl_AM_RLC.sn_FieldLength));
8457          /*TODO: Check the timer value when sent by real CU */
8458          amCfgToSet->ulAmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_Reassembly);
8459          amCfgToSet->ulAmCfg.statProhTmr = convertProhibitTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_StatusProhibit);
8460       }
8461
8462       /* DL AM */
8463       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
8464       {
8465          amCfgToSet->dlAmCfg.snLenDl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->ul_AM_RLC.sn_FieldLength));
8466          amCfgToSet->dlAmCfg.pollRetxTmr = covertPollRetxTmrEnumToValue(rlcAmCfg->ul_AM_RLC.t_PollRetransmit);
8467          amCfgToSet->dlAmCfg.pollPdu   = covertPollPduEnumToValue(rlcAmCfg->ul_AM_RLC.pollPDU);
8468          amCfgToSet->dlAmCfg.pollByte  = covertPollByteEnumToValue(rlcAmCfg->ul_AM_RLC.pollByte);
8469          amCfgToSet->dlAmCfg.maxRetxTh = covertMaxRetxEnumToValue(rlcAmCfg->ul_AM_RLC.maxRetxThreshold);
8470       }
8471    }
8472 }
8473
8474 /*******************************************************************
8475  *
8476  * @brief Function to build Um Bi Info
8477  *
8478  * @details
8479  *
8480  *    Function : extractRlcUmBiCfg
8481  *
8482  *    Functionality: Function to build Um Bi Info
8483  *
8484  * @params[in] UmBiDirBearerCfg *
8485  *             void *
8486  *
8487  * @return ROK/RFAILED
8488  *
8489  * ****************************************************************/
8490
8491 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
8492 {
8493    if(rlcBiCfg)
8494    {
8495       /* UL UM BI DIR Cfg */
8496       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
8497       {
8498          umBiCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->dl_UM_RLC.sn_FieldLength));
8499          umBiCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcBiCfg->dl_UM_RLC.t_Reassembly);
8500       }
8501
8502       /* DL UM BI DIR Cfg */
8503       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
8504          umBiCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->ul_UM_RLC.sn_FieldLength));
8505    }
8506 }
8507
8508 /*******************************************************************
8509  *
8510  * @brief Function to build Um Ul Info
8511  *
8512  * @details
8513  *
8514  *    Function : extractRlcUmUlCfg
8515  *
8516  *    Functionality: Function to build Um Ul Info
8517  *
8518  * @params[in] UmUniDirUlBearerCfg *
8519  *             void *
8520  *
8521  * @return ROK/RFAILED
8522  *
8523  * ****************************************************************/
8524
8525 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
8526 {
8527    if(umUlCfg)
8528    {
8529       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
8530       {
8531          umUlCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umUlCfg->dl_UM_RLC.sn_FieldLength));
8532          umUlCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(umUlCfg->dl_UM_RLC.t_Reassembly);
8533       }
8534    }
8535 }
8536
8537 /*******************************************************************
8538  *
8539  * @brief Function to build Um Uni Dl Info
8540  *
8541  * @details
8542  *
8543  *    Function : extractRlcUmDlCfg
8544  *
8545  *    Functionality: Function to build Um Uni Dl Info
8546  *
8547  * @params[in] UmUniDirDlBearerCfg *
8548  *             void *
8549  *
8550  * @return ROK/RFAILED
8551  *
8552  * ****************************************************************/
8553 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
8554 {
8555    if(umDlCfg)
8556    {
8557       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
8558          umDlCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umDlCfg->ul_UM_RLC.sn_FieldLength));
8559    }
8560 }
8561
8562 /*******************************************************************
8563  *
8564  * @brief Function to extractRlcModeCfg
8565  *
8566  * @details
8567  *
8568  *    Function : extractRlcModeCfg
8569  *
8570  *    Functionality: Function to extractRlcModeCfg
8571  *
8572  * @params[in] RLC_Config_t *
8573  *             RlcBearerCfg *
8574  *             void  *
8575  * @return ROK/RFAILED
8576  *
8577  * ****************************************************************/
8578 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
8579 {
8580    if(lcCfg)
8581    {
8582       switch(rlcMode)
8583       {
8584          case RLC_AM :
8585             {
8586                if(lcCfg->choice.am)
8587                {
8588                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
8589                   if(rlcDbCfg->u.amCfg)
8590                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
8591                }
8592                break;
8593             }
8594          case RLC_UM_BI_DIRECTIONAL :
8595             {
8596                if(lcCfg->choice.um_Bi_Directional)
8597                {
8598                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
8599                   if(rlcDbCfg->u.umBiDirCfg)
8600                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
8601                }
8602                break;
8603             }
8604          case RLC_UM_UNI_DIRECTIONAL_UL :
8605             {
8606                if(lcCfg->choice.um_Uni_Directional_DL)
8607                {
8608                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
8609                   if(rlcDbCfg->u.umUniDirUlCfg)
8610                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
8611                }
8612                break;
8613             }
8614          case RLC_UM_UNI_DIRECTIONAL_DL :
8615             {
8616                if(lcCfg->choice.um_Uni_Directional_UL)
8617                {
8618                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
8619                   if(rlcDbCfg->u.umUniDirDlCfg)
8620                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
8621                }
8622                break;
8623             }
8624          default:
8625             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
8626             break;
8627       }
8628    }
8629 }
8630
8631 /*******************************************************************
8632  *
8633  * @brief Function to extract extractUlLcCfg
8634  *
8635  * @details
8636  *
8637  *    Function : extractUlLcCfg
8638  *
8639  *    Functionality: Function to extract extractUlLcCfg
8640  *
8641  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
8642  * @return void
8643  *
8644  * ****************************************************************/
8645
8646 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
8647 {
8648    if(ulLcCfg)
8649    {
8650       if(ulLcCfg->ul_SpecificParameters)
8651       {
8652          f1UlLcCfg->priority = \
8653             ulLcCfg->ul_SpecificParameters->priority;
8654       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
8655       {
8656          f1UlLcCfg->lcGroup = \
8657            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
8658       }
8659       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
8660       {
8661          f1UlLcCfg->schReqId = \
8662            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
8663       }
8664       f1UlLcCfg->pbr = \
8665          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
8666       f1UlLcCfg->bsd = \
8667          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
8668       }
8669    }
8670 }
8671
8672 /*******************************************************************
8673 *
8674 * @brief Function to extract Snssai Cfg Info from CU
8675 *
8676 * @details
8677 *
8678 *    Function : extractDrbSnssaiCfg
8679 *
8680 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
8681 *
8682 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
8683 * @return ROK/RFAILED
8684 *
8685 * ****************************************************************/
8686
8687 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
8688 {
8689    if(!(*snssaiToBeShared))
8690    {
8691       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
8692       if(snssaiToBeShared == NULLP)
8693       {
8694          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
8695          return RFAILED;
8696       }
8697    }
8698    if(RecvSnssai)
8699    {
8700       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
8701       if(RecvSnssai->sD)
8702       {
8703          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
8704       }
8705       else
8706       {
8707          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
8708          return RFAILED;
8709       }
8710    }
8711    return ROK;
8712 }
8713
8714 /*******************************************************************
8715  *
8716  * @brief Function to procRlcLcCfg
8717  *
8718  * @details
8719  *
8720  *    Function : procRlcLcCfg
8721  *
8722  *    Functionality: Function to procRlcLcCfg
8723  *
8724  * @params[in] rbId, lcId, rbType, rlcMod
8725  *             RLC_Config_t *, RlcBearerCfg * ,
8726  * @return void
8727  *
8728  * ****************************************************************/
8729
8730 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
8731    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
8732 {
8733    DRB_Information_t *drbInfo;
8734
8735    lcCfg->rbId   = rbId;
8736    lcCfg->configType = configType;
8737
8738    if(rbType == RB_TYPE_SRB)
8739    {
8740       lcCfg->rbType = RB_TYPE_SRB;
8741       lcCfg->lcId   = rbId;
8742       lcCfg->lcType = LCH_DCCH;
8743       lcCfg->rlcMode = RLC_AM;
8744    }
8745    else if(rbType == RB_TYPE_DRB)
8746    {
8747       lcCfg->rbType = RB_TYPE_DRB;
8748       lcCfg->lcId   = lcId;
8749       lcCfg->lcType = LCH_DTCH;
8750       lcCfg->rlcMode = rlcMode;
8751    }
8752    if(f1RlcCfg) /* rlc mode config recived */
8753    {
8754       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
8755    }
8756    if(qoSInformation != NULLP)
8757    {
8758       if(qoSInformation->present == QoSInformation_PR_choice_extension)
8759       {
8760          if(qoSInformation->choice.choice_extension->value.present ==\
8761                QoSInformation_ExtIEs__value_PR_DRB_Information)
8762          {
8763             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
8764             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
8765             {
8766                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
8767                return;
8768             }
8769          }
8770       }
8771    }
8772 }
8773
8774 /*******************************************************************
8775  *
8776  * @brief Fills DrbQos Info received by CU
8777  *
8778  * @details
8779  *
8780  *    Function : extractQosInfo
8781  *
8782  *    Functionality: Fills DrbQos Info received  by CU
8783  *
8784  * @params[in] DrbQosInfo *qosToAdd,
8785  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
8786  * @return void
8787  *
8788  * ****************************************************************/
8789
8790 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
8791 {
8792    uint8_t qosCntIdx = 0;
8793    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
8794
8795    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
8796    qosToAdd->u.nonDyn5Qi.fiveQi     =\
8797                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
8798    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
8799    {
8800       qosToAdd->u.nonDyn5Qi.avgWindow = \
8801                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
8802    }
8803    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
8804                                            *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
8805    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
8806    {
8807       qosToAdd->u.nonDyn5Qi.priorLevel = \
8808                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
8809    }
8810    qosToAdd->ngRanRetPri.priorityLevel = \
8811                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
8812    qosToAdd->ngRanRetPri.preEmptionCap = \
8813                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
8814    qosToAdd->ngRanRetPri.preEmptionVul = \
8815                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
8816    if(qosFlowCfg->gBR_QoS_Flow_Information)
8817    {
8818       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
8819             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
8820             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
8821       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
8822             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
8823             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
8824       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
8825             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
8826             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
8827       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
8828             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
8829             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
8830    }
8831    /*Extracting PDU_SESSION_ID*/
8832    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
8833    if(qosIeExt)
8834    {
8835       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
8836       {
8837          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
8838                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
8839          {
8840             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
8841             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
8842          }
8843       }
8844    }
8845    qosToAdd->ulPduSessAggMaxBitRate = 0;
8846 }
8847
8848 /*******************************************************************
8849  *
8850  * @brief Function to extract GTP Tunnel Info from CU
8851  *
8852  * @details
8853  *
8854  *    Function : extractUpTnlInfo
8855  *
8856  *    Functionality: Function to extract GTP Tunnel Info from CU
8857  *
8858  * @params[in] F1AP message
8859  * @return ROK/RFAILED
8860  *
8861  * ****************************************************************/
8862
8863 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
8864    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
8865 {
8866    uint8_t tnlIdx;
8867    uint32_t ipv4_du = 0;
8868    GTPTunnel_t *gtpTunnel = NULLP;
8869
8870    upTnlInfo->drbId = drbId;
8871    upTnlInfo->configType = configType;
8872 #ifdef O1_ENABLE
8873    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
8874 #else
8875    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
8876 #endif
8877
8878    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
8879    {
8880       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
8881       {
8882          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
8883          {
8884             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
8885             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
8886             if(upTnlInfo->tnlCfg1 == NULLP)
8887             {
8888                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
8889                return RFAILED;
8890             }
8891             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
8892             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
8893             if(gtpTunnel->gTP_TEID.size > 0)
8894             {
8895                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
8896             }
8897          }
8898          break;
8899       }
8900    }
8901    return ROK;
8902 }
8903
8904 /*******************************************************************
8905 *
8906 * @brief Function to extract Drb Qos Cfg Info from CU
8907 *
8908 * @details
8909 *
8910 *    Function : extractDrbQosCfg
8911 *
8912 *    Functionality: Function to extract Drb Qos Cfg Info from CU
8913 *
8914 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
8915 * @return ROK/RFAILED
8916 *
8917 * ****************************************************************/
8918
8919 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
8920 {
8921    if(!macLcToAdd->drbQos)
8922    {
8923       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
8924       if(macLcToAdd->drbQos == NULLP)
8925       {
8926          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
8927          return RFAILED;
8928       }
8929
8930    }
8931    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
8932    {
8933       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
8934       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
8935    }
8936    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
8937    {
8938       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
8939       return RFAILED;
8940    }
8941    return ROK;
8942 }
8943 /*******************************************************************
8944  *
8945  * @brief Function to extract DRB info received from CU
8946  *
8947  * @details
8948  *
8949  *    Function : extractDrbCfg
8950  *
8951  *    Functionality: Function to extract DRB info received from CU
8952  *
8953  * @params[in] F1AP message
8954  * @return void
8955  *
8956  * ****************************************************************/
8957 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
8958 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
8959 {
8960    DRB_Information_t *drbInfo = NULLP;
8961
8962    if(drbItem != NULLP)
8963    {
8964       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
8965       {
8966          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
8967          return RFAILED;
8968       }
8969       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
8970       {
8971          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
8972          {
8973             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
8974             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
8975             {
8976                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
8977                return RFAILED;
8978             }
8979          }
8980       }
8981    }
8982    else if(drbSetupModItem != NULLP)
8983    {
8984       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
8985       upTnlInfo) != ROK)
8986       {
8987          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
8988          return RFAILED;
8989       }
8990       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
8991       {
8992          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
8993          QoSInformation_ExtIEs__value_PR_DRB_Information)
8994          {
8995             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
8996             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
8997             {
8998                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
8999                return RFAILED;
9000             }
9001
9002          }
9003       }
9004    }
9005    else if(drbModItem != NULLP)
9006    {
9007       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
9008       upTnlInfo) != ROK)
9009       {
9010          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
9011          return RFAILED;
9012       }
9013       if(drbModItem->qoSInformation != NULLP)
9014       {
9015          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
9016          {
9017             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
9018                   QoSInformation_ExtIEs__value_PR_DRB_Information)
9019             {
9020                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
9021                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
9022                {
9023                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
9024                   return RFAILED;
9025                }
9026
9027             }
9028          }
9029       }
9030    }
9031    return ROK;
9032 }
9033
9034 /*******************************************************************
9035  *
9036  * @brief Function to extract RB info received from CU
9037  *
9038  * @details
9039  *
9040  *    Function : extractMacRbCfg
9041  *
9042  *    Functionality: Function to extract RB info received from CU
9043  *
9044  * @params[in] F1AP message
9045  * @return ROK/RFAILED
9046  *
9047  * ****************************************************************/
9048
9049 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
9050 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
9051 {
9052    if(drbCfg != NULLP)
9053    {
9054       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
9055       {
9056          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
9057          return RFAILED;
9058       }
9059    }
9060    else if(drbSetupModCfg != NULLP)
9061    {
9062       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
9063       {
9064          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
9065          return RFAILED;
9066       }
9067    }
9068    else if(drbModCfg != NULLP)
9069    {
9070       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
9071       {
9072          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
9073          return RFAILED;
9074       }
9075    }
9076    else
9077    {
9078       lcCfg->drbQos = NULLP;
9079       lcCfg->snssai = NULLP;
9080       if(lcCfg->lcId == SRB2_LCID)
9081          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
9082       else
9083          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
9084    }
9085    if(ulLcCfg)
9086    {
9087       lcCfg->ulLcCfgPres = true;
9088       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
9089    }
9090    else
9091       lcCfg->ulLcCfgPres = false;
9092    return ROK;
9093 }
9094
9095 /*******************************************************************
9096  *
9097  * @brief Function processing LC config info received from CU
9098  *
9099  * @details
9100  *
9101  *    Function : procMacLcCfg
9102  *
9103  *    Functionality: Function processing LC config info received from CU
9104  *
9105  * @params[in] F1AP message
9106  * @return ROK/RFAILED
9107  *
9108  * ****************************************************************/
9109
9110 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
9111 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
9112 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
9113 {
9114    uint8_t ret = ROK;
9115
9116    lcCfg->lcId = lcId;
9117    lcCfg->configType = configType;
9118    if(rbType == RB_TYPE_SRB)
9119    {
9120       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
9121    }
9122    else if(rbType == RB_TYPE_DRB)
9123    {
9124       if(drbItem != NULL)
9125         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
9126       else if(drbSetupModItem != NULL)
9127         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
9128       else if(drbModItem != NULL)
9129         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
9130    }
9131    return ret;
9132 }
9133
9134 /*******************************************************************
9135  *
9136  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
9137  *
9138  * @details
9139  *
9140  *    Function : extractRlcCfgToAddMod
9141  *
9142  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
9143  *
9144  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
9145  *             DuUeCfg Pointer
9146  * @return ROK/RFAILED
9147  *
9148  * ****************************************************************/
9149
9150 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
9151 {
9152   uint8_t idx, rbId, lcId, rlcMode, rbType;
9153   RLC_Config_t *f1RlcCfg = NULLP;
9154   LogicalChannelConfig_t *macUlLcCfg = NULLP;
9155
9156   for(idx = 0; idx < lcCfg->list.count; idx++)
9157   {
9158      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
9159      if(lcCfg->list.array[idx]->servedRadioBearer)
9160      {
9161         /* RadioBearer for SRB/DRB */
9162         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
9163         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
9164         {
9165            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
9166            rbType = RB_TYPE_SRB;
9167         }
9168         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
9169         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
9170         {
9171            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
9172            rbType = RB_TYPE_DRB;
9173         }
9174         else
9175         {
9176            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
9177            return RFAILED;
9178         }
9179         /* MAC UL LC Config */
9180         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
9181         {
9182            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
9183         }
9184      }
9185      else
9186      {
9187         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
9188         return RFAILED;
9189      }
9190      /* RLC Mode Config */
9191      if(lcCfg->list.array[idx]->rlc_Config)
9192      {
9193         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
9194         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
9195      }
9196
9197      /* Filling RLC/MAC Config*/
9198      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
9199      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
9200      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
9201      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
9202      {
9203         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
9204         return RFAILED;
9205      }
9206      (ueCfgDb->numRlcLcs)++;
9207      (ueCfgDb->numMacLcs)++;
9208          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
9209                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
9210   }
9211   //TODO: To send the failure cause in UeContextSetupRsp
9212   return ROK;
9213 }
9214
9215 /*******************************************************************
9216  *
9217  * @brief DeAlloc pdsch serv cell config info
9218  *
9219  * @details
9220  *
9221  *    Function : freeMacPdschServCellInfo
9222  *
9223  *    Functionality: DeAlloc pdsch serv cell config info
9224  *
9225  * @params[in] PdschServCellCfg pointer
9226  * @return void
9227  *
9228  * ****************************************************************/
9229
9230 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
9231 {
9232    if(pdsch->xOverhead)
9233    {
9234       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
9235    }
9236    if(pdsch->codeBlkGrpFlushInd)
9237    {
9238       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
9239    }
9240    if(pdsch->maxCodeBlkGrpPerTb)
9241    {
9242       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
9243    }
9244    if(pdsch->maxMimoLayers)
9245    {
9246       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
9247    }
9248 }
9249
9250 /*******************************************************************
9251  *
9252  * @brief Free Serving cell Info
9253  *
9254  * @details
9255  *
9256  *    Function : freeMacServingCellInfo
9257  *
9258  *    Functionality: Free Serving cell Info
9259  *
9260  * @params[in] ServCellCfgInfo *srvCellCfg
9261  * @return void
9262  *
9263  * ****************************************************************/
9264 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
9265 {
9266    uint8_t timeDomRsrcIdx;
9267
9268    if(srvCellCfg->initDlBwp.pdschPresent)
9269    {
9270       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
9271       {
9272          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
9273             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
9274       }
9275    }
9276
9277    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
9278    if(srvCellCfg->bwpInactivityTmr)
9279    {
9280       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9281    }
9282
9283    if(srvCellCfg->initUlBwp.pucchPresent)
9284    {
9285       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9286    }
9287 }
9288
9289 /*******************************************************************
9290  *
9291  * @brief Free cell Grp Cfg Info
9292  *
9293  * @details
9294  *
9295  *    Function : freeUeReCfgCellGrpInfo
9296  *
9297  *    Functionality: Free cell Grp Cfg Info
9298  *
9299  * @params[in] MacUeCfg*  duUeCfg
9300  * @return void
9301  *
9302  * ****************************************************************/
9303
9304 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
9305 {
9306    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
9307 }
9308
9309 /*******************************************************************
9310  *
9311  * @brief Fills Reconfig SchReqReConfig
9312  *
9313  * @details
9314  *
9315  *    Function : extractSchReqReConfig
9316  *
9317  *    Functionality: Fills Reconfig SchReqReConfig
9318  *
9319  * @params[in] SchedulingRequestConfig_t *cuSchedReq
9320  *             SchedReqCfg*  macSchedReq
9321  * @return void
9322  *
9323  * ****************************************************************/
9324 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
9325 {
9326    uint8_t schReqIdx = 0;
9327    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
9328    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
9329
9330    if(cuSchedReq->schedulingRequestToAddModList)
9331    {
9332       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
9333       if(schReqListToAdd->list.count)
9334       {
9335          macSchedReq->addModListCount = schReqListToAdd->list.count;
9336          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
9337          {
9338             macSchedReq->addModList[schReqIdx].schedReqId = \
9339                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
9340             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
9341                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
9342             macSchedReq->addModList[schReqIdx].srTransMax    =\
9343                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
9344          }
9345       }
9346    }
9347    /* Scheduling Req To release */
9348    if(cuSchedReq->schedulingRequestToReleaseList)
9349    {
9350       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
9351       if(schReqListToRel->list.count)
9352       {
9353          macSchedReq->relListCount = schReqListToRel->list.count;
9354          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
9355          {
9356             macSchedReq->relList[schReqIdx] = \
9357                *schReqListToRel->list.array[schReqIdx];
9358          }
9359       }
9360    }
9361 }
9362
9363 /*******************************************************************
9364  *
9365  * @brief Fills TagReconfig
9366  *
9367  * @details
9368  *
9369  *    Function : extractTagReconfig
9370  *
9371  *    Functionality: Fills extractTagReconfig
9372  *
9373  * @params[in] TAG_Config_t *cuTagCfg
9374  *             TagCfg *macTagCfg
9375  * @return void
9376  *
9377  * ****************************************************************/
9378
9379 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
9380 {
9381   uint8_t tagIdx = 0;
9382   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
9383   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
9384
9385   /* Tag config to AddMod */
9386   if(cuTagCfg->tag_ToAddModList)
9387   {
9388      tagListToAddMod = cuTagCfg->tag_ToAddModList;
9389      if(tagListToAddMod->list.count)
9390      {
9391         macTagCfg->addModListCount = tagListToAddMod->list.count;
9392         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
9393         {
9394            macTagCfg->addModList[tagIdx].tagId =\
9395               tagListToAddMod->list.array[tagIdx]->tag_Id;
9396            macTagCfg->addModList[tagIdx].timeAlignTimer = \
9397
9398               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
9399         }
9400      }
9401   }
9402   /* Tag config to release */
9403   if(cuTagCfg->tag_ToReleaseList)
9404   {
9405      tagListToRel = cuTagCfg->tag_ToReleaseList;
9406      if(tagListToRel->list.count)
9407      {
9408         macTagCfg->relListCount = tagListToRel->list.count;
9409         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
9410         {
9411            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
9412         }
9413      }
9414   }
9415 }
9416
9417 /*******************************************************************
9418  *
9419  * @brief Fills PdcchCfg received by CU
9420  *
9421  * @details
9422  *
9423  *    Function : extractPdcchCfg
9424  *
9425  *    Functionality: Fills PdcchCfg received  by CU
9426  *
9427  * @params[in] PDCCH_Config_t *cuPdcchCfg,
9428  *             PdcchConfig *duPdcchCfg
9429  * @return void
9430  *
9431  * ****************************************************************/
9432
9433 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
9434 {
9435    uint8_t cRsetIdx = 0;
9436    uint8_t srchSpcIdx = 0;
9437
9438    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
9439    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
9440    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
9441    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
9442
9443
9444    /* Control Resource Set To Add/Mod List */
9445    if(cuPdcchCfg->controlResourceSetToAddModList)
9446    {
9447       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
9448       if(cRsetToAddModList->list.count)
9449       {
9450          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
9451          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
9452          {
9453             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
9454                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
9455             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
9456                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
9457             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
9458                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
9459                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
9460
9461             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
9462                 cRsetToAddModList->list.array[cRsetIdx]->duration;
9463
9464             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
9465                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
9466             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
9467             {
9468                //TODO: handle the case for Interleaved
9469             }
9470             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
9471                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
9472             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
9473             {
9474                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
9475                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
9476             }
9477          }
9478       }
9479    }
9480    /* Control Resource Set To Release List */
9481    if(cuPdcchCfg->controlResourceSetToReleaseList)
9482    {
9483       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
9484       if(cRsetToRelList->list.count)
9485       {
9486          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
9487          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
9488          {
9489             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
9490          }
9491       }
9492    }
9493
9494    /* Search space To Add/Mod List */
9495    if(cuPdcchCfg->searchSpacesToAddModList)
9496    {
9497       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
9498       if(srchSpcToAddModList->list.count)
9499       {
9500          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
9501          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
9502          {
9503             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
9504                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
9505             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
9506                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
9507             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
9508             {
9509                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
9510                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
9511             }
9512             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
9513             {
9514                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
9515                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
9516             }
9517             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
9518             {
9519                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
9520                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
9521                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
9522                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
9523                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
9524                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
9525
9526                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
9527                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
9528
9529                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
9530                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
9531             }
9532             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
9533             {
9534                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
9535                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
9536                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
9537                {
9538                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
9539                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
9540                }
9541
9542             }
9543          }
9544       }
9545    }
9546    /* Search space To Rel List */
9547    if(cuPdcchCfg->searchSpacesToReleaseList)
9548    {
9549       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
9550       if(srchSpcToRelList->list.count)
9551       {
9552          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
9553          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
9554          {
9555             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
9556                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
9557          }
9558       }
9559    }
9560 }
9561
9562 /*******************************************************************
9563  *
9564  * @brief Fills PdschCfg received by CU
9565  *
9566  * @details
9567  *
9568  *    Function : extractPdschCfg
9569  *
9570  *    Functionality: Fills PdschCfg received  by CU
9571  *
9572  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
9573  *                   which we have stored in F1UeContextSetupDb,
9574  *             PdschConfig *macPdschCfg = Used to Store the information which
9575  *                   needs to send in other layer, as well as this can be the variable
9576  *                   which stores the information in DuCb,
9577  *             PdschConfig *storedPdschCfg =  Null in case of sending the
9578  *                   information to other layer else it will have stored pdsch
9579  *                   configuration in copyOfmacUeCfg.
9580  * @return void
9581  *
9582  * ****************************************************************/
9583
9584 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
9585 {
9586    uint8_t timeDomIdx;
9587    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
9588
9589    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
9590    {
9591       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
9592             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
9593       {
9594          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
9595          {
9596             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
9597                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
9598          }
9599       }
9600    }
9601    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
9602    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
9603    {
9604       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
9605       if(timeDomAlloc->present ==\
9606             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
9607       {
9608          if(timeDomAlloc->choice.setup)
9609          {
9610             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
9611             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
9612             {
9613                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
9614                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
9615                {
9616                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
9617                   {
9618                      if(storedPdschCfg)
9619                      {
9620                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
9621                         {
9622                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
9623                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
9624                         }
9625                         else
9626                         {
9627                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
9628                         }
9629                      }
9630                      else
9631                      {
9632                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
9633                      }
9634                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
9635                      {
9636                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
9637                         return;
9638                      }
9639                   }
9640                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
9641                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
9642                }
9643                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
9644                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
9645                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
9646                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
9647             }
9648          }
9649       }
9650    }
9651    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
9652    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
9653       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
9654    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
9655    {
9656       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
9657       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
9658       {
9659          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
9660          {
9661             macPdschCfg->bundlingInfo.StaticBundling.size = \
9662                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
9663          }
9664       }
9665    }
9666    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
9667    {
9668       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
9669    }
9670
9671 }
9672
9673 /*******************************************************************
9674  *
9675  * @brief Fills PdschServingCellCfg received by CU
9676  *
9677  * @details
9678  *
9679  *    Function : extractPdschServingCellCfg
9680  *
9681  *    Functionality: Fills PdschCfg received  by CU
9682  *
9683  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
9684  *             PdschServCellCfg *macUePdschSrvCellCfg
9685  * @return ROK/RFAILED
9686  *
9687  * ****************************************************************/
9688
9689 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
9690 {
9691    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
9692    {
9693       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
9694       {
9695          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
9696          {
9697             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
9698                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
9699          }
9700          else
9701          {
9702             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
9703             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
9704             {
9705                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
9706                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
9707             }
9708             else
9709             {
9710                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
9711                return RFAILED;
9712             }
9713          }
9714          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
9715          {
9716             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
9717                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
9718          }
9719          else
9720          {
9721             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
9722             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
9723             {
9724                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
9725                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
9726             }
9727             else
9728             {
9729                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
9730                return RFAILED;
9731             }
9732          }
9733       }
9734    }
9735    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
9736    {
9737       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
9738    }
9739    if(cuPdschSrvCellCfg->ext1)
9740    {
9741       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
9742       {
9743         if(macUePdschSrvCellCfg->maxMimoLayers)
9744         {
9745            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
9746         }
9747         else
9748         {
9749            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
9750            if(macUePdschSrvCellCfg->maxMimoLayers)
9751            {
9752               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
9753            }
9754            else
9755            {
9756               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
9757               return RFAILED;
9758            }
9759         }
9760       }
9761    }
9762    if(cuPdschSrvCellCfg->xOverhead)
9763    {
9764       if(macUePdschSrvCellCfg->xOverhead)
9765       {
9766          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
9767       }
9768       else
9769       {
9770          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
9771          if(macUePdschSrvCellCfg->xOverhead)
9772          {
9773             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
9774          }
9775          else
9776          {
9777             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
9778             return RFAILED;
9779          }
9780       }
9781    }
9782    return ROK;
9783 }
9784
9785 /*******************************************************************
9786  *
9787  * @brief Fills PuschCfg received by CU
9788  *
9789  * @details
9790  *
9791  *    Function : extractPuschCfg
9792  *
9793  *    Functionality: Fills PuschCfg received  by CU
9794  *
9795  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
9796  *             PuschCfg *macPuschCfg
9797  * @return void
9798  *
9799  * ****************************************************************/
9800
9801 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
9802 {
9803    uint8_t timeDomIdx = 0;
9804    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
9805    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
9806
9807    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
9808    {
9809       if(cuPuschCfg->choice.setup)
9810       {
9811          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
9812          {
9813              macPuschCfg->dataScramblingId = \
9814                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
9815          }
9816          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
9817          {
9818             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
9819             {
9820                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
9821                {
9822                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
9823                   if(dmrsUlCfg->dmrs_AdditionalPosition)
9824                   {
9825                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
9826                         *(dmrsUlCfg->dmrs_AdditionalPosition);
9827                   }
9828                   if(dmrsUlCfg->transformPrecodingDisabled)
9829                   {
9830                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
9831                      {
9832                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
9833                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
9834                      }
9835                   }
9836                }
9837             }
9838          }
9839          /*Res Alloc Type for UL */
9840          if(cuPuschCfg->choice.setup->resourceAllocation)
9841          {
9842             macPuschCfg->resourceAllocType = \
9843                cuPuschCfg->choice.setup->resourceAllocation;
9844          }
9845          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
9846          {
9847             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
9848             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
9849             {
9850                if(timeDomAllocList->choice.setup)
9851                {
9852                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
9853                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
9854                   {
9855                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
9856                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
9857                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
9858                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
9859                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
9860                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
9861                   }
9862                }
9863             }
9864          }
9865          if(cuPuschCfg->choice.setup->transformPrecoder)
9866             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
9867       }
9868    }
9869 }
9870
9871 /*******************************************************************
9872  *
9873  * @brief Function to fill pucch Power Control
9874  *
9875  * @details
9876  *
9877  *    Function : extractPucchPowerControl
9878  *
9879  *    Functionality: Function to fill pucch Power Control
9880  *
9881  * @params[in] PucchPowerControl *pwrCtrl,
9882  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
9883  * @return void
9884  *
9885  * ****************************************************************/
9886
9887 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
9888 {
9889    uint8_t arrIdx;
9890
9891    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
9892       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
9893    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
9894       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
9895    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
9896       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
9897    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
9898       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
9899    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
9900       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
9901    if(cuPwrCtrlCfg->p0_Set)
9902    {
9903       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
9904       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
9905       {
9906          pwrCtrl->p0Set[arrIdx].p0PucchId =\
9907             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
9908          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
9909             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
9910       }
9911    }
9912    if(cuPwrCtrlCfg->pathlossReferenceRSs)
9913    {
9914       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
9915       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
9916       {
9917          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
9918             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
9919       }
9920    }
9921 }
9922
9923  /*******************************************************************
9924  *
9925  * @brief Function to extractResrcSetToAddModList sent by CU
9926  *
9927  * @details
9928  *
9929  *    Function : extractResrcSetToAddModList
9930  *
9931  *    Functionality: Fucntion to extractResrcSetToAddModList
9932  *
9933  * @params[in] PucchResrcSetCfg pointer,
9934  *             struct PUCCH_Config__resourceSetToAddModList pointer
9935  * @return void
9936  *
9937  * ****************************************************************/
9938
9939 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
9940 {
9941    uint8_t arrIdx, rsrcListIdx;
9942
9943    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
9944    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
9945    {
9946       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
9947          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
9948       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
9949          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
9950       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
9951       {
9952          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
9953             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
9954       }
9955
9956       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
9957       {
9958          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
9959             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
9960       }
9961       else
9962       {
9963          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
9964       }
9965    }
9966 }/* End of extractResrcSetToAddModList */
9967
9968 /*******************************************************************
9969  *
9970  * @brief Fills extractResrcToAddModList sent by CU
9971  *
9972  * @details
9973  *
9974  *    Function : extractResrcToAddModList
9975  *
9976  *    Functionality: Fills extractResrcToAddModList
9977  *
9978  * @params[in] PucchResrcCfg pointer,
9979  *             struct PUCCH_Config__resourceToAddModList pointer
9980  * @return ROk/RFAILED
9981  *
9982  * ****************************************************************/
9983
9984 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
9985 {
9986    uint8_t arrIdx;
9987
9988    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
9989    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
9990    {
9991       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
9992         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
9993       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
9994         cuResrcList->list.array[arrIdx]->startingPRB;
9995       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
9996       {
9997          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
9998            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
9999       }
10000       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
10001       {
10002          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
10003            *cuResrcList->list.array[arrIdx]->secondHopPRB;
10004       }
10005       /* PUCCH RSRC FORMAT */
10006       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
10007       {
10008          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
10009          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
10010          {
10011             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
10012             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
10013             {
10014                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
10015                return RFAILED;
10016             }
10017             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
10018                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
10019             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
10020                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
10021             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
10022                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
10023          }
10024       }
10025       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
10026       {
10027          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
10028          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
10029          {
10030             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
10031             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
10032             {
10033                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
10034                return RFAILED;
10035             }
10036             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
10037                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
10038             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
10039                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
10040             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
10041                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
10042             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
10043                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
10044          }
10045       }
10046       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
10047       {
10048          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
10049          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
10050          {
10051             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
10052             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
10053             {
10054                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
10055                return RFAILED;
10056             }
10057             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
10058                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
10059             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
10060                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
10061             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
10062                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
10063          }
10064       }
10065       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
10066       {
10067          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
10068          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
10069          {
10070             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
10071             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
10072             {
10073                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
10074                return RFAILED;
10075             }
10076             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
10077                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
10078             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
10079                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
10080             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
10081                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
10082          }
10083       }
10084       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
10085       {
10086          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
10087          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
10088          {
10089             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
10090             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
10091             {
10092                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
10093                return RFAILED;
10094             }
10095             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
10096                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
10097             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
10098                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
10099             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
10100                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
10101             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
10102                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
10103          }
10104       }
10105    }
10106    return ROK;
10107
10108 }/* End of extractResrcToAddModList */
10109
10110 /*******************************************************************
10111  *
10112  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
10113  *
10114  * @details
10115  *
10116  *    Function : fillPucchSchedReqPeriodAndOffset
10117  *
10118  *    Functionality: To fillPucchSchedReqPeriodAndOffset
10119  *
10120  * @params[in] macPeriodicty,
10121  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
10122  * @return void
10123  *
10124  * ****************************************************************/
10125
10126 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
10127    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
10128 {
10129    macPeriodicty = cuPeriodicty->present;
10130    switch(macPeriodicty)
10131    {
10132       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
10133          {
10134             macOffset     = cuPeriodicty->choice.sym2;
10135             break;
10136          }
10137       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
10138          {
10139             macOffset     = cuPeriodicty->choice.sym6or7;
10140             break;
10141          }
10142       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
10143          {
10144             macOffset     = cuPeriodicty->choice.sl1;
10145             break;
10146          }
10147       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
10148          {
10149             macOffset = cuPeriodicty->choice.sl2;
10150             break;
10151          }
10152       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
10153          {
10154             macOffset = cuPeriodicty->choice.sl4;
10155             break;
10156          }
10157       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
10158          {
10159             macOffset = cuPeriodicty->choice.sl5;
10160             break;
10161          }
10162       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
10163          {
10164             macOffset = cuPeriodicty->choice.sl8;
10165             break;
10166          }
10167       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
10168          {
10169             macOffset = cuPeriodicty->choice.sl10;
10170             break;
10171          }
10172       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
10173          {
10174             macOffset = cuPeriodicty->choice.sl16;
10175             break;
10176          }
10177       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
10178          {
10179             macOffset = cuPeriodicty->choice.sl20;
10180             break;
10181          }
10182       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
10183          {
10184             macOffset = cuPeriodicty->choice.sl40;
10185             break;
10186          }
10187       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
10188          {
10189             macOffset = cuPeriodicty->choice.sl80;
10190             break;
10191          }
10192       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
10193          {
10194             macOffset = cuPeriodicty->choice.sl160;
10195             break;
10196          }
10197       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
10198          {
10199             macOffset = cuPeriodicty->choice.sl320;
10200             break;
10201          }
10202       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
10203          {
10204             macOffset = cuPeriodicty->choice.sl640;
10205             break;
10206          }
10207       default :
10208          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
10209    }
10210 }
10211
10212 /*******************************************************************
10213  *
10214  * @brief Function to extractPucchFormatCfg sent by CU
10215  *
10216  * @details
10217  *
10218  *    Function : extractPucchFormatCfg
10219  *
10220  *    Functionality: Function to extractPucchFormatCfg
10221  *
10222  * @params[in] PucchFormatCfg pointer,
10223  *             PUCCH_FormatConfig_t pointer
10224  * @return void
10225  *
10226  * ****************************************************************/
10227
10228 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
10229  {
10230     if(cuFormatCfg->interslotFrequencyHopping)
10231        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
10232     if(cuFormatCfg->additionalDMRS)
10233        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
10234     if(cuFormatCfg->maxCodeRate)
10235        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
10236     if(cuFormatCfg->nrofSlots)
10237        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
10238     if(cuFormatCfg->pi2BPSK)
10239        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
10240     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
10241        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
10242  }/* End of extractPucchFormatCfg */
10243
10244 /*******************************************************************
10245  *
10246  * @brief Function to extractSchedReqCfgToAddMod sent by CU
10247  *
10248  * @details
10249  *
10250  *    Function : extractSchedReqCfgToAddMod
10251  *
10252  *    Functionality: Function to extractSchedReqCfgToAddMod
10253  *
10254  * @params[in] PucchSchedReqCfg pointer,
10255  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
10256  * @return void
10257  *
10258  * ****************************************************************/
10259
10260 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
10261 {
10262    uint8_t arrIdx;
10263
10264    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
10265    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
10266    {
10267       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
10268          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
10269       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
10270          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
10271       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
10272       {
10273          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
10274             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
10275       }
10276       if(cuSchedReqList->list.array[arrIdx]->resource)
10277       {
10278          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
10279             *cuSchedReqList->list.array[arrIdx]->resource;
10280       }
10281    }
10282
10283 }/* End of extractSchedReqCfgToAddMod */
10284
10285  /*******************************************************************
10286  *
10287  * @brief Fills PucchCfg received by CU
10288  *
10289  * @details
10290  *
10291  *    Function : extractPucchCfg
10292  *
10293  *    Functionality: Fills PucchCfg received  by CU
10294  *
10295  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
10296  *                is send by CU, which we have stored in F1UeContextSetupDb,
10297  *             PucchCfg *macPucchCfg = Used to Store the information which
10298  *                needs to send in other layer, as well as this can be the variable
10299  *                which stores the information in DuCb,
10300  *             PucchCfg *storedPucchCfg = Null in case of sending the
10301  *                information to other layer else it will have Pucch Cfg which
10302  *                we have stored in copyOfmacUeCfg.
10303  * @return ROK/RFAILED
10304  *
10305  * ****************************************************************/
10306
10307 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
10308 PucchCfg *storedPucchCfg)
10309 {
10310    uint8_t arrIdx;
10311
10312    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
10313    {
10314       if(cuPucchCfg->choice.setup)
10315       {
10316          /* Resource Set Cfg */
10317          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
10318          {
10319             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
10320             if(macPucchCfg->resrcSet == NULLP)
10321             {
10322                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
10323                return RFAILED;
10324             }
10325             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
10326             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
10327          }
10328
10329          /* Resource Cfg */
10330          if(cuPucchCfg->choice.setup->resourceToAddModList)
10331          {
10332             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
10333             if(macPucchCfg->resrc == NULLP)
10334             {
10335                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
10336                return RFAILED;
10337             }
10338             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
10339             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
10340          }
10341
10342          /* Format 1 Cfg */
10343          if(cuPucchCfg->choice.setup->format1)
10344          {
10345             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
10346             if(macPucchCfg->format1 == NULLP)
10347             {
10348                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
10349                return RFAILED;
10350             }
10351             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
10352             extractPucchFormatCfg(macPucchCfg->format1,\
10353                cuPucchCfg->choice.setup->format1->choice.setup);
10354          }
10355
10356          /* Format 2 Cfg */
10357          if(cuPucchCfg->choice.setup->format2)
10358          {
10359             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
10360             if(macPucchCfg->format2 == NULLP)
10361             {
10362                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
10363                return RFAILED;
10364             }
10365             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
10366             extractPucchFormatCfg(macPucchCfg->format2,\
10367                cuPucchCfg->choice.setup->format2->choice.setup);
10368          }
10369
10370          /* Format 3 Cfg */
10371          if(cuPucchCfg->choice.setup->format3)
10372          {
10373             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
10374             if(macPucchCfg->format3 == NULLP)
10375             {
10376                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
10377                return RFAILED;
10378             }
10379             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
10380             extractPucchFormatCfg(macPucchCfg->format3,\
10381                cuPucchCfg->choice.setup->format3->choice.setup);
10382          }
10383
10384          /* Format 4 Cfg */
10385          if(cuPucchCfg->choice.setup->format4)
10386          {
10387             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
10388             if(macPucchCfg->format4 == NULLP)
10389             {
10390                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
10391                return RFAILED;
10392             }
10393             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
10394             extractPucchFormatCfg(macPucchCfg->format4,\
10395                cuPucchCfg->choice.setup->format4->choice.setup);
10396          }
10397
10398          /* Sched Req List */
10399          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
10400          {
10401             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
10402             if(macPucchCfg->schedReq == NULLP)
10403             {
10404                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
10405                return RFAILED;
10406             }
10407             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
10408             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
10409             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
10410          }
10411
10412          /*TODO: Add support for  Spatial Info */
10413
10414          /* MultiCsiCfg */
10415          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
10416          {
10417             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
10418             if(macPucchCfg->multiCsiCfg == NULLP)
10419             {
10420                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
10421                return RFAILED;
10422             }
10423             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
10424             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
10425             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
10426             {
10427                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
10428                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
10429             }
10430          }
10431
10432          /* Dl_DataToUL_ACK */
10433          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
10434     {
10435        if(storedPucchCfg)
10436        {
10437           if(storedPucchCfg->dlDataToUlAck)
10438           {
10439              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
10440           }
10441           else
10442           {
10443             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10444           }
10445        }
10446        else
10447        {
10448           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10449        }
10450        if(macPucchCfg->dlDataToUlAck == NULLP)
10451        {
10452           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
10453           return RFAILED;
10454        }
10455        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
10456        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
10457        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
10458        {
10459           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
10460           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
10461        }
10462          }
10463
10464          /* Power Control */
10465          if(cuPucchCfg->choice.setup->pucch_PowerControl)
10466          {
10467             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
10468             if(macPucchCfg->powerControl == NULLP)
10469             {
10470                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
10471                return RFAILED;
10472             }
10473             extractPucchPowerControl(macPucchCfg->powerControl,\
10474                cuPucchCfg->choice.setup->pucch_PowerControl);
10475          }
10476       }
10477    }
10478    return ROK;
10479 }
10480
10481 /*******************************************************************
10482  *
10483  * @brief Fills ServingCellReconfig received by CU
10484  *
10485  * @details
10486  *
10487  *    Function : extractSpCellDedicatedCfg
10488  *
10489  *    Functionality: Fills ServingCellReconfig received  by CU
10490  *
10491  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
10492  *                  CU, which we have stored in F1UeContextSetupDb,
10493  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
10494  *                  which  needs to send in other layer, as well as this can be the
10495  *                  variable which stores the information in DuCb,
10496  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
10497  *                  information to other layer else it will have ServCellCfgInfo which
10498  *                  we have stored in copyOfmacUeCfg.
10499  * @return ROK/RFAILD
10500  *
10501  * ****************************************************************/
10502 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
10503 ServCellCfgInfo *storedSrvCellCfg)
10504 {
10505    uint8_t ret = ROK;
10506    BWP_DownlinkDedicated_t *dlBwp = NULLP;
10507    BWP_UplinkDedicated_t   *ulBwp = NULLP;
10508
10509    if(cuSrvCellCfg->initialDownlinkBWP)
10510    {
10511       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
10512       if(dlBwp->pdcch_Config)
10513       {
10514          if(dlBwp->pdcch_Config->choice.setup)
10515          {
10516             macSrvCellCfg->initDlBwp.pdcchPresent = true;
10517             if(storedSrvCellCfg)
10518             {
10519                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
10520                {
10521                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
10522                }
10523                else
10524                {
10525                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
10526                }
10527             }
10528             else
10529             {
10530                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
10531             }
10532          }
10533       }
10534       if(dlBwp->pdsch_Config)
10535       {
10536          if(dlBwp->pdsch_Config->choice.setup)
10537          {
10538             macSrvCellCfg->initDlBwp.pdschPresent = true;
10539
10540             if(storedSrvCellCfg)
10541             {
10542                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
10543                {
10544                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
10545                }
10546                else
10547                {
10548                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
10549                         &storedSrvCellCfg->initDlBwp.pdschCfg);
10550                }
10551             }
10552             else
10553             {
10554                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
10555             }
10556          }
10557       }
10558    }
10559    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
10560       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
10561    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
10562       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
10563    if(cuSrvCellCfg->bwp_InactivityTimer)
10564    {
10565       if(macSrvCellCfg->bwpInactivityTmr)
10566       {
10567          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
10568       }
10569       else
10570       {
10571          macSrvCellCfg->bwpInactivityTmr = NULLP;
10572          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
10573          if(macSrvCellCfg->bwpInactivityTmr)
10574          {
10575             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
10576          }
10577          else
10578          {
10579             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
10580             return RFAILED;
10581          }
10582       }
10583    }
10584    if(cuSrvCellCfg->pdsch_ServingCellConfig)
10585    {
10586       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
10587       {
10588          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
10589          if(ret == RFAILED)
10590          {
10591             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
10592             return RFAILED;
10593          }
10594       }
10595    }
10596    if(cuSrvCellCfg->uplinkConfig)
10597    {
10598       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
10599       {
10600          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
10601          if(ulBwp->pusch_Config)
10602          {
10603             macSrvCellCfg->initUlBwp.puschPresent = true;
10604             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
10605          }
10606          if(ulBwp->pucch_Config)
10607          {
10608             macSrvCellCfg->initUlBwp.pucchPresent = true;
10609             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
10610             if(storedSrvCellCfg)
10611             {
10612                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
10613                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
10614                else
10615                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
10616                   &storedSrvCellCfg->initUlBwp.pucchCfg);
10617             }
10618             else
10619             {
10620                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
10621             }
10622          }
10623       }
10624       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
10625          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
10626    }
10627    return ret;
10628 }
10629 /*******************************************************************
10630  *
10631  * @brief Fills Reconfig Cell group Info received by CU
10632  *
10633  * @details
10634  *
10635  *    Function : extractUeReCfgCellInfo
10636  *
10637  *    Functionality: Fills Reconfig Cell group Info received by CU
10638  *
10639  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
10640  *                       is send by CU, which we have stored in F1UeContextSetupDb
10641  *             MacUeCfg *MacUeCfg = Used to Store the information,
10642  *                      which needs to send in other layer, as well as this can be
10643  *                      the variable which stores the information in DuCb,
10644  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
10645  *                      information to other layer else it will have copyOfmacUeCfg
10646  *                      which we have stored in F1UeContextSetupDb.
10647  *
10648  * @return ROK/RFAILED
10649  *
10650  * ****************************************************************/
10651 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
10652 {
10653    uint8_t ret = ROK;
10654    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
10655    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
10656    SpCellConfig_t            *spcellCfg = NULLP;
10657    ServingCellConfig_t       *servCellCfg = NULLP;
10658
10659    if(cellGrp)
10660    {
10661       /* Fill MacCell Group Reconfig  */
10662       if(cellGrp->mac_CellGroupConfig)
10663       {
10664          macUeCfg->macCellGrpCfgPres = true;
10665          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
10666          if(macCellGroup->schedulingRequestConfig)
10667          {
10668             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
10669          }
10670          if(macCellGroup->tag_Config)
10671          {
10672             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
10673          }
10674          if(macCellGroup->bsr_Config)
10675          {
10676             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
10677             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
10678             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
10679             {
10680                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
10681                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
10682             }
10683          }
10684          if(macCellGroup->phr_Config)
10685          {
10686             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
10687             {
10688                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
10689                if(macCellGroup->phr_Config->choice.setup)
10690                {
10691                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
10692                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
10693                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
10694                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
10695                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
10696                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
10697                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
10698                   macCellGroup->phr_Config->choice.setup->multiplePHR;
10699                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
10700                   macCellGroup->phr_Config->choice.setup->dummy;
10701                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
10702                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
10703                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
10704                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
10705                }
10706             }
10707          }
10708       }
10709       /* Fill Physical Cell Group Reconfig */
10710       if(cellGrp->physicalCellGroupConfig)
10711       {
10712          macUeCfg->phyCellGrpCfgPres = true;
10713          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
10714          if(phyCellGrpCfg->p_NR_FR1)
10715          {
10716             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
10717                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
10718          }
10719          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
10720       }
10721       /* Fill SpCell Reconfig */
10722       if(cellGrp->spCellConfig)
10723       {
10724          macUeCfg->spCellCfgPres = true;
10725          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
10726          if(spcellCfg->servCellIndex)
10727          {
10728             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
10729          }
10730          /* Fill Serving cell Reconfig info */
10731          if(cellGrp->spCellConfig->spCellConfigDedicated)
10732          {
10733             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
10734             if(storedMacUeCfg)
10735             {
10736                if(!storedMacUeCfg->spCellCfgPres)
10737                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
10738                else
10739                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
10740                         &storedMacUeCfg->spCellCfg.servCellCfg);
10741             }
10742             else
10743             {
10744                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
10745             }
10746             if(ret == RFAILED)
10747             {
10748                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
10749             }
10750          }
10751       }
10752    }
10753    return ret;
10754 }
10755 /*******************************************************************
10756 *
10757 * @brief free the memory allocated by decoder
10758 *
10759 * @details
10760 *
10761 *    Function : freeAperDecodeNrcgi
10762 *
10763 *    Functionality: Free Nrcgi values
10764 *
10765 * @params[in] NRCGI_t *nrcgi
10766 * @return void
10767 *
10768 * ****************************************************************/
10769
10770
10771 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
10772 {
10773     if(nrcgi->pLMN_Identity.buf != NULLP)
10774     {
10775        free(nrcgi->pLMN_Identity.buf);
10776     }
10777     if(nrcgi->nRCellIdentity.buf != NULLP)
10778     {
10779        free(nrcgi->nRCellIdentity.buf);
10780     }
10781 }
10782 /*******************************************************************
10783 *
10784 * @brief free the memory allocated by decoder
10785 *
10786 * @details
10787 *
10788 *    Function : freeAperDecodeCuToDuInfo
10789 *
10790 *    Functionality:  Free Cu To Du Information
10791 *
10792 * @params[in] CUtoDURRCInformation_t *rrcMsg
10793 * @return void
10794 *
10795 * ****************************************************************/
10796
10797
10798 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
10799 {
10800    uint8_t ieIdx =0;
10801    uint8_t arrIdx =0;
10802
10803    if(rrcMsg->uE_CapabilityRAT_ContainerList)
10804    {
10805       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
10806          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
10807       free(rrcMsg->uE_CapabilityRAT_ContainerList);
10808    }
10809
10810    if(rrcMsg->iE_Extensions)
10811    {
10812       if(rrcMsg->iE_Extensions->list.array)
10813       {
10814          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
10815          {
10816             if(rrcMsg->iE_Extensions->list.array[ieIdx])
10817             {
10818                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
10819                {
10820                   case ProtocolIE_ID_id_CellGroupConfig:
10821                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
10822                      {
10823                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
10824                      }
10825                      break;
10826                   default:
10827                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
10828                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
10829                      break;
10830                }
10831             }
10832          }
10833          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
10834          {
10835             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
10836          }
10837          free(rrcMsg->iE_Extensions->list.array);
10838
10839       }
10840
10841       free(rrcMsg->iE_Extensions);
10842    }
10843 }
10844 /*******************************************************************
10845 *
10846 * @brief free the memory allocated by decoder
10847 *
10848 * @details
10849 *
10850 *    Function : freeAperDecodeSplCellList
10851 *
10852 *    Functionality: Free Spl Cell List
10853                     where memory allocated by aper_decoder
10854 *
10855 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
10856 * @return void
10857 *
10858 * ****************************************************************/
10859
10860
10861 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
10862 {
10863     uint8_t  cellIdx =0;
10864
10865     if(spCellLst->list.array != NULLP)
10866     {
10867        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
10868        {
10869           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
10870           {
10871              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
10872           }
10873           if(spCellLst->list.array[cellIdx]!=NULLP)
10874           {
10875              free(spCellLst->list.array[cellIdx]);
10876           }
10877        }
10878        free(spCellLst->list.array);
10879     }
10880 }
10881 /*******************************************************************
10882 *
10883 * @brief free the memory allocated by decoder
10884 *
10885 * @details
10886 *
10887 *    Function : freeAperDecodeSRBSetup
10888 *
10889 *    Functionality: added free part for the memory allocated by aper_decoder
10890 *
10891 * @params[in] SRBs_ToBeSetup_List_t *srbSet
10892 * @return void
10893 *
10894 ****************************************************************/
10895
10896
10897 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
10898 {
10899     uint8_t srbIdx =0;
10900     if(srbSet->list.array != NULLP)
10901     {
10902        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
10903        {
10904           if(srbSet->list.array[srbIdx]!=NULLP)
10905           {
10906              free(srbSet->list.array[srbIdx]);
10907           }
10908        }
10909        free(srbSet->list.array);
10910     }
10911 }
10912
10913 /*******************************************************************
10914 *
10915 * @brief free the memory allocated by decoder
10916 *
10917 * @details
10918 *
10919 *    Function : freeAperDecodeULTnlInfo
10920 *
10921 *    Functionality: added free part for the memory allocated by aper_decoder
10922 *
10923 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10924 * @return void
10925 *
10926 * ****************************************************************/
10927
10928
10929 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
10930 {
10931    uint8_t ulIdx=0;
10932    if(ulInfo->list.array != NULLP)
10933    {
10934       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
10935       {
10936          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
10937          {
10938             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
10939             {
10940                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10941                      transportLayerAddress.buf != NULLP)
10942                {
10943                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10944                         !=NULLP)
10945                   {
10946                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
10947                   }
10948                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10949                         transportLayerAddress.buf);
10950                }
10951                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
10952             }
10953          }
10954          if(ulInfo->list.array[ulIdx]!=NULLP)
10955          {
10956             free(ulInfo->list.array[ulIdx]);
10957          }
10958       }
10959       free(ulInfo->list.array);
10960    }
10961 }
10962 /*******************************************************************
10963 *
10964 * @brief free the memory allocated by decoder
10965 *
10966 * @details
10967 *
10968 *    Function : freeAperDecodeDRBSetup
10969 *
10970 *    Functionality: free DRBSetup which is allocated by decoder
10971 *
10972 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
10973 * @return void
10974 *
10975 * ****************************************************************/
10976
10977 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
10978 {
10979    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
10980    uint8_t  flowIdx =0;
10981    uint8_t  drbIdx =0;
10982
10983    if(drbSet->list.array != NULLP)
10984    {
10985       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
10986       {
10987          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
10988          {
10989             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10990             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
10991             {
10992                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10993                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
10994                {
10995                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10996                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
10997                   {
10998                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10999                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11000                      {
11001
11002                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
11003                         {
11004
11005                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
11006                            {
11007
11008                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
11009                                     buf!=NULLP)
11010                               {
11011
11012                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
11013                                        flows_Mapped_To_DRB_List.list.array != NULLP)
11014                                  {
11015
11016                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11017                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
11018                                     {
11019
11020                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11021                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
11022                                        {
11023                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11024                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11025                                                 qoSFlowLevelQoSParameters.\
11026                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
11027                                           {
11028                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11029                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11030                                                    qoSFlowLevelQoSParameters.\
11031                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
11032                                              {
11033
11034                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11035                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11036                                                       qoSFlowLevelQoSParameters.\
11037                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11038                                                 {
11039
11040
11041                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11042                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11043                                                          qoSFlowLevelQoSParameters.\
11044                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11045                                                 }
11046
11047                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11048                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11049                                                       qoSFlowLevelQoSParameters.\
11050                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11051                                              }
11052
11053                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11054
11055                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11056                                                    qoSFlowLevelQoSParameters.\
11057                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
11058                                           }
11059                                        }
11060                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11061                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
11062                                        {
11063
11064                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11065                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
11066                                        }
11067                                     }
11068
11069                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11070                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
11071                                  }
11072
11073                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11074                                        DRB_Information.sNSSAI.sD->buf);
11075                               }
11076
11077                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
11078                            }
11079
11080                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
11081
11082                         }
11083
11084                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11085
11086                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11087                      }
11088
11089                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11090                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11091                   }
11092
11093                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11094                         qoS_Characteristics.choice.non_Dynamic_5QI);
11095                }
11096                free(drbSetItem->qoSInformation.choice.choice_extension);
11097             }
11098             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
11099             if(drbSetItem->uLConfiguration)
11100             {
11101                free(drbSetItem->uLConfiguration);
11102             }
11103          }
11104          if(drbSet->list.array[drbIdx]!=NULLP)
11105          {
11106             free(drbSet->list.array[drbIdx]);
11107          }
11108       }
11109       free(drbSet->list.array);
11110    }
11111 }
11112
11113
11114 /*******************************************************************
11115  *
11116  * @brief builds Mac Cell Cfg
11117  *
11118  * @details
11119  *
11120  *    Function : procUeReCfgCellInfo
11121  *
11122  *    Functionality: builds Mac Cell Cfg
11123  *
11124  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
11125  *                       needs to send in other layer, as well as this can be
11126  *                       the variable which stores the information in DuCb.
11127  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
11128  *                       information to other layer else it will have copyOfmacUeCfg
11129  *                       which we have stored in F1UeContextSetupDb
11130  *             void *cellInfo = CellGroupConfigRrc_t information which is send
11131  *                        by CU, which we have stored in F1UeContextSetupDb
11132  *
11133  * @return void
11134  *
11135  * ****************************************************************/
11136 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
11137 {
11138    uint8_t ret = ROK;
11139    CellGroupConfigRrc_t *cellGrp = NULLP;
11140
11141    if(cellInfo)
11142    {
11143       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
11144       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
11145       if(ret == RFAILED)
11146          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
11147    }
11148    if(ret == RFAILED)
11149    {
11150       freeUeReCfgCellGrpInfo(macUeCfgToSend);
11151    }
11152    return ret;
11153 }
11154
11155 /*******************************************************************
11156  *
11157  * @brief Filling modulation info in mac ue cfg
11158  *
11159  * @details
11160  *
11161  *    Function : duFillModulationDetails
11162  *
11163  *    Functionality: Filling modulation info in mac ue cfg
11164  *
11165  * @params[in] MAC UE Config to be updated
11166  *             Current UE configuration
11167  *             UE NR capability from CU
11168  * @return ROK     - success
11169  *         RFAILED - failure
11170  *
11171  * ****************************************************************/
11172 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
11173 {
11174    UE_NR_Capability_t *ueNrCap=NULLP;
11175
11176    if(!ueCap)
11177    {
11178       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
11179       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
11180    }
11181    else
11182    {
11183       ueNrCap = (UE_NR_Capability_t *)ueCap;
11184
11185       /* Filling DL modulation info */
11186       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
11187          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
11188          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
11189       {
11190          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
11191          {
11192             case ModulationOrder_qpsk:
11193                {
11194                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
11195                   break;
11196                }
11197             case ModulationOrder_qam16:
11198                {
11199                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
11200                   break;
11201                }
11202             case ModulationOrder_qam64:
11203                {
11204                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
11205                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
11206                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
11207                   break;
11208                }
11209             case ModulationOrder_qam256:
11210                {
11211                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
11212                   break;
11213                }
11214             default:
11215                {
11216                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
11217                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
11218                   break;
11219                }
11220          }
11221       }
11222       else
11223       {
11224          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
11225       }
11226
11227       /* Filling UL modulation info */
11228       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
11229          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
11230          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
11231       {
11232          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
11233          {
11234             case ModulationOrder_qpsk:
11235                {
11236                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
11237                   break;
11238                }
11239             case ModulationOrder_qam16:
11240                {
11241                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
11242                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
11243                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
11244                   break;
11245                }
11246             case ModulationOrder_qam64:
11247                {
11248                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
11249                   break;
11250                }
11251             case ModulationOrder_qam256:
11252                {
11253                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
11254                   break;
11255                }
11256             default:
11257                {
11258                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
11259                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
11260                   break;
11261                }
11262          }
11263       }
11264       else
11265       {
11266          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
11267       }
11268    }
11269 }
11270
11271 /*******************************************************************
11272  *
11273  * @brief Function to extract info from CU to DU RRC container extension
11274  *
11275  * @details
11276  *
11277  *    Function : extractCuToDuRrcInfoExt
11278  *
11279  *    Functionality: Function to extract info from CU to DU RRC container
11280  *    extension
11281  *
11282  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
11283  *
11284  * @return ROK
11285  *         RFAILED
11286  *
11287  * ****************************************************************/
11288 uint8_t extractCuToDuRrcInfoExt(ProtocolExtensionContainer_4624P16_t *protocolIeExtn, DuUeCfg *ueCfgDb)
11289 {
11290    uint8_t idx2 =0;
11291    uint16_t id =0;
11292    uint16_t recvBufLen =0;
11293    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
11294    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
11295    asn_dec_rval_t rval; /* Decoder return value */
11296    memset(&rval, 0, sizeof(asn_dec_rval_t));
11297
11298    if(protocolIeExtn)
11299    {
11300       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
11301       {
11302          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
11303          id = extIeInfo->id;
11304          switch(id)
11305          {
11306             case ProtocolIE_ID_id_CellGroupConfig:
11307                {
11308                   recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
11309                   /* decoding the CellGroup Buf received */
11310                   DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
11311                   if(cellGrpCfg)
11312                   {
11313                      memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
11314                      rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
11315                            extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
11316                      if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11317                      {
11318                         DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
11319                         return RFAILED;
11320                      }
11321                      xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
11322                      if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
11323                         return NULLP;
11324                      ueCfgDb->cellGrpCfg = cellGrpCfg;
11325                   }
11326                   break;
11327                }
11328
11329             case ProtocolIE_ID_id_HandoverPreparationInformation:
11330                {
11331                   DU_LOG("\nHLAL Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
11332                   return RFAILED;
11333                }
11334
11335             default:
11336                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
11337                break;
11338          }
11339       }
11340    }
11341    return ROK;
11342 }
11343
11344 /*******************************************************************
11345  *
11346  * @brief Fills Srb List received by CU
11347  *
11348  * @details
11349  *
11350  *    Function : procSrbListToSetup
11351  *
11352  *    Functionality: Fills Srb List received  by CU
11353  *
11354  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
11355  *             LcCfg pointer
11356  *             RlcBearerCfg pointer
11357  * @return void
11358  *
11359  * ****************************************************************/
11360 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
11361 {
11362
11363    /* Filling RLC INFO */
11364    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
11365
11366    /* Filling MAC INFO */
11367    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
11368    {
11369       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
11370       return RFAILED;
11371    }
11372
11373    return ROK;
11374 }
11375
11376
11377
11378 /*******************************************************************
11379  *
11380  * @brief extract Srb List received by CU
11381  *
11382  * @details
11383  *
11384  *    Function : extractSrbListToSetup
11385  *
11386  *    Functionality: extract Srb List received by CU
11387  *                   for both MAC and RLC
11388  *
11389  * @params[in] SRBs_ToBeSetup_Item_t pointer
11390  *             DuUeCfg pointer
11391  * @return ROK/RFAIED
11392  *
11393  * ****************************************************************/
11394
11395 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
11396 {
11397    uint8_t ret, srbIdx;
11398    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
11399
11400    if(srbCfg)
11401    {
11402       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
11403       {
11404          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
11405          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
11406          {
11407             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
11408             ret = RFAILED;
11409             break;
11410          }
11411          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
11412          {
11413             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
11414             ret = RFAILED;
11415             break;
11416          }
11417          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
11418          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
11419          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
11420                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
11421          ueCfgDb->numRlcLcs++;
11422          ueCfgDb->numMacLcs++;
11423          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
11424                srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
11425          if(ret == RFAILED)
11426          {
11427             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
11428             break;
11429          }
11430       }
11431    }
11432    else
11433       ret = RFAILED;
11434
11435    return ret;
11436 }
11437
11438 /*******************************************************************
11439  *
11440  * @brief Fills Drb List received by CU
11441  *
11442  * @details
11443  *
11444  *    Function : procDrbListToSetupMod
11445  *
11446  *    Functionality: Fills Drb List received by CU
11447  *                   for both MAC and RLC
11448  *
11449  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
11450  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
11451  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
11452  * @return void
11453  *
11454  * ****************************************************************/
11455
11456 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
11457 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
11458 {
11459    uint8_t cfgIdx = 0;
11460    RlcMode rlcModeInfo;
11461
11462    if(drbItem != NULLP)
11463    {
11464       /* Filling RLC INFO */
11465       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
11466       qoSInformation);
11467
11468       /* Filling MAC INFO */
11469       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
11470       {
11471          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
11472          return RFAILED;
11473       }
11474    }
11475    else if(drbSetupModItem != NULLP)
11476    {
11477       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
11478       &drbSetupModItem->qoSInformation);
11479
11480       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
11481       {
11482          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
11483          return RFAILED;
11484       }
11485    }
11486    else if(drbModItem != NULLP)
11487    {
11488       /* Drb to Mod IEs doesnot have rlcMode to be modified
11489        * in ASN. Hence no change in RLC configurations */
11490       if(storedRlcUeCfg != NULLP)
11491       {
11492          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
11493          {
11494             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
11495             {
11496                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
11497                break;
11498             }
11499          }
11500       }
11501
11502       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
11503       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
11504       {
11505          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
11506          return RFAILED;
11507       }
11508    }
11509    return ROK;
11510 }
11511
11512 /*******************************************************************
11513  *
11514  * @brief extract Drb List received by CU
11515  *
11516  * @details
11517  *
11518  *    Function : extractDrbListToSetupMod
11519  *
11520  *    Functionality: extract Drb List received by CU
11521  *                   for both MAC and RLC
11522  *
11523  * @params[in] DRBs_ToBeSetup_Item_t pointer
11524  *             DuUeCfg pointer
11525  * @return ROK/RFAIED
11526  *
11527  * ****************************************************************/
11528
11529 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
11530  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
11531 {
11532    uint8_t ret, drbIdx = 0, lcId = 0;
11533    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
11534    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
11535    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
11536
11537    ret = ROK;
11538    if(drbCount > 0)
11539    {
11540       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
11541       {
11542          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
11543          {
11544             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
11545             ret = RFAILED;
11546             break;
11547          }
11548          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
11549          {
11550             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
11551             ret = RFAILED;
11552             break;
11553          }
11554          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
11555          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
11556
11557          if(drbModCfg != NULLP)
11558          {
11559             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
11560             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
11561             if(lcId < MIN_DRB_LCID)
11562             {
11563                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
11564                break;
11565             }
11566             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
11567             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
11568             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
11569             if(ret == RFAILED)
11570             {
11571                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
11572                break;
11573             }
11574
11575          }
11576          else
11577          {
11578             lcId = getDrbLcId(drbBitMap);
11579             if(lcId == RFAILED)
11580             {
11581                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
11582                ret = RFAILED;
11583                break;
11584             }
11585             if(drbCfg != NULL)
11586             {
11587                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
11588                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
11589                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
11590                if(ret == RFAILED)
11591                {
11592                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
11593                   break;
11594                }
11595             }
11596             else if(drbSetupModCfg != NULL)
11597             {
11598                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
11599                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
11600                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
11601                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
11602                if(ret == RFAILED)
11603                {
11604                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
11605                   break;
11606                }
11607                ueCfgDb->numDrbSetupMod++;
11608             }
11609          }
11610          ueCfgDb->numRlcLcs++;
11611          ueCfgDb->numMacLcs++;
11612          ueCfgDb->numDrb++;
11613
11614          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
11615                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
11616          if(ret == RFAILED)
11617          {
11618             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
11619             break;
11620          }
11621       }
11622    }
11623    else
11624       ret = RFAILED;
11625
11626    return ret;
11627 }
11628
11629 /*******************************************************************
11630  *
11631  * @brief Function to extract Dl RRC Msg received from CU
11632  *
11633  * @details
11634  *
11635  *    Function : extractDlRrcMsg
11636  *
11637  *    Functionality: Function to extract Dl RRC Msg received from CU
11638  *
11639  * @params[in] F1AP message
11640  * @return ROK     - success
11641  *         RFAILED - failure
11642  *
11643  * ****************************************************************/
11644
11645 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
11646    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
11647 {
11648    uint8_t ret = ROK;
11649    dlRrcMsg->rrcMsgSize = rrcContainer->size;
11650    if(dlRrcMsg->rrcMsgSize > 0)
11651    {
11652       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
11653       if(!dlRrcMsg->rrcMsgPdu)
11654       {
11655          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
11656          ret = RFAILED;
11657       }
11658       else
11659       {
11660          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
11661          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
11662          dlRrcMsg->srbId = SRB1_LCID;
11663          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
11664       }
11665    }
11666    return ret;
11667 }
11668
11669 /*******************************************************************
11670  *
11671  * @brief Extract UE capability info
11672  *
11673  * @details
11674  *
11675  *    Function : extractUeCapability
11676  *
11677  *    Functionality: Extract UE capability info and stores in ue Cb
11678  *
11679  * @params[in] Octet string of UE capability RAT container list
11680  * @return ROK     - success
11681  *         RFAILED - failure
11682  *
11683  * ****************************************************************/
11684 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
11685 {
11686    uint8_t  idx;
11687    uint16_t recvBufLen;
11688    asn_dec_rval_t rval;
11689    UE_NR_Capability_t  *ueNrCap = NULLP;
11690    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
11691
11692    /* Decoding UE Capability RAT Container List */
11693    recvBufLen = ueCapablityListBuf->size;
11694    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11695    if(!ueCapRatContList)
11696    {
11697       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
11698       return NULLP;
11699    }
11700    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11701    memset(&rval, 0, sizeof(asn_dec_rval_t));
11702    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
11703           ueCapablityListBuf->buf, recvBufLen, 0, 0);
11704    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11705    {
11706       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
11707       return NULLP;
11708    }
11709    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
11710
11711    /* Free encoded buffer after decoding */
11712
11713    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
11714    {
11715       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
11716       {
11717          /* Decoding UE NR Capability */
11718           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
11719           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
11720           if(!ueNrCap)
11721           {
11722              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
11723              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11724              return NULLP;
11725           }
11726           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
11727           memset(&rval, 0, sizeof(asn_dec_rval_t));
11728           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
11729                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
11730           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11731           {
11732              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
11733              return NULLP;
11734           }
11735           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
11736
11737           /* Free encoded buffer after decoding */
11738           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
11739       }
11740       free(ueCapRatContList->list.array[idx]);
11741    }
11742
11743    /* Free Memory*/
11744    free(ueCapRatContList->list.array);
11745    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11746    return ueNrCap;
11747 }
11748
11749 /*******************************************************************
11750 *
11751 * @brief free UE context setup request from CU
11752 *
11753 * @details
11754 *
11755 *    Function : freeAperDecodeF1UeContextSetupReq
11756 *
11757 *    Functionality: freeing part for the memory allocated by aper_decoder
11758 *
11759 * @params[in] F1AP message
11760 * @return ROK     - success
11761 *         RFAILED - failure
11762 *
11763 * ****************************************************************/
11764 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
11765 {
11766    uint8_t ieIdx = 0;
11767
11768    if(ueSetReq->protocolIEs.list.array != NULLP)
11769    {
11770       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
11771       {
11772          if(ueSetReq->protocolIEs.list.array[ieIdx])
11773          {
11774             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
11775             {
11776                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11777                   break;
11778                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11779                   break;
11780                case ProtocolIE_ID_id_SpCell_ID:
11781                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
11782                   break;
11783                case ProtocolIE_ID_id_ServCellIndex:
11784                   break;
11785                case ProtocolIE_ID_id_SpCellULConfigured:
11786                   break;
11787                case ProtocolIE_ID_id_CUtoDURRCInformation:
11788
11789                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
11790                   break;
11791                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
11792
11793                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
11794                   break;
11795                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
11796
11797                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
11798                   break;
11799                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
11800
11801                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
11802                   break;
11803                case ProtocolIE_ID_id_RRCContainer:
11804                   {
11805
11806                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
11807                      {
11808
11809                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
11810                      }
11811                      break;
11812                   }
11813                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11814                   break;
11815                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
11816                   {
11817                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
11818                      {
11819                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
11820                      }
11821                      break;
11822                   }
11823                default:
11824                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
11825             }
11826             free(ueSetReq->protocolIEs.list.array[ieIdx]);
11827          }
11828       }
11829       free(ueSetReq->protocolIEs.list.array);
11830    }
11831 }
11832 /*******************************************************************
11833  *
11834  * @brief Process UE context setup request from CU
11835  *
11836  * @details
11837  *
11838  *    Function : procF1UeContextSetupReq
11839  *
11840  *    Functionality: Process UE context setup request from CU
11841  *
11842  * @params[in] F1AP message
11843  * @return ROK     - success
11844  *         RFAILED - failure
11845  *
11846  * ****************************************************************/
11847 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
11848 {
11849    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0, servCellIdx = 0;
11850    bool ueCbFound = false;
11851    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
11852    DuUeCb   *duUeCb = NULL;
11853    UEContextSetupRequest_t   *ueSetReq = NULL;
11854    DRBs_ToBeSetup_List_t *drbCfg = NULL;
11855
11856    ret = ROK;
11857
11858    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
11859    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
11860    {
11861       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
11862       {
11863          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11864             {
11865                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11866                break;
11867             }
11868          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11869             {
11870                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11871                break;
11872             }
11873          case ProtocolIE_ID_id_ServCellIndex:
11874             {
11875                servCellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
11876                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
11877                {
11878                   for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11879                   {
11880                      if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
11881                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
11882                      {
11883                         ueCbFound = true;
11884                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
11885                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
11886                         if(duUeCb->f1UeDb)
11887                         {
11888                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
11889                            duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
11890                            duUeCb->f1UeDb->cellIdx = cellIdx;
11891                         }
11892                         else
11893                         {
11894                            DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
11895                            ret = RFAILED;
11896                         }
11897                         break;
11898                      }
11899                      else
11900                         ueCbFound = false;
11901
11902                   }
11903                   if(ueCbFound)
11904                      break;
11905                }
11906                if(!ueCbFound)
11907                {
11908                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
11909                   ret = RFAILED;
11910                }
11911                break;
11912             }
11913          case ProtocolIE_ID_id_SpCellULConfigured:
11914             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
11915                UL, SUL or UL+SUL for the indicated cell for the UE */
11916             break;
11917          case ProtocolIE_ID_id_CUtoDURRCInformation:
11918             {
11919                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
11920                {
11921                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
11922                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
11923                   uE_CapabilityRAT_ContainerList, duUeCb);
11924                }
11925
11926                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
11927                {
11928                   if(extractCuToDuRrcInfoExt(ueSetReq->protocolIEs.list.array[ieIdx]->\
11929                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
11930                   {
11931                      DU_LOG("\nERROR  -->  F1AP: Failed to extract CU to DU RRC information extension IE");
11932                      //TODO: Update the failure cause in ue context Setup Response
11933                      ret = RFAILED;
11934                   }
11935                }
11936                break;
11937             }
11938          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
11939             {
11940                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
11941                break;
11942             }
11943          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
11944             {
11945                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
11946                &duUeCb->f1UeDb->duUeCfg))
11947                {
11948                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
11949                   //TODO: Update the failure cause in ue context Setup Response
11950                   ret = RFAILED;
11951                }
11952                break;
11953             }
11954          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
11955             {
11956                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
11957
11958                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
11959                   {
11960                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
11961                      //TODO: Update the failure cause in ue context Setup Response
11962                      ret = RFAILED;
11963                   }
11964                break;
11965             }
11966          case ProtocolIE_ID_id_RRCContainer:
11967             {
11968                /* Filling Dl RRC Msg Info */
11969                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
11970                if(!duUeCb->f1UeDb->dlRrcMsg)
11971                {
11972                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
11973                   ret = RFAILED;
11974                }
11975                else
11976                {
11977                   duUeCb->f1UeDb->dlRrcMsgPres = true;
11978                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
11979                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
11980                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
11981                }
11982                break;
11983             }
11984          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11985             {
11986                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
11987                {
11988                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
11989                }
11990                else
11991                {
11992                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
11993                }
11994                break;
11995             }
11996          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
11997             {
11998                /* MaximumBitRate Uplink */
11999                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
12000                if(bitRateSize > 0)
12001                {
12002                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
12003                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
12004                   {
12005                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
12006                      ret = RFAILED;
12007                   }
12008                   else
12009                   {
12010                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
12011                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
12012                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
12013                   }
12014                }
12015                else
12016                   ret = RFAILED;
12017                break;
12018             }
12019          default:
12020             {
12021                break;
12022             }
12023       }
12024    }
12025    if(ret == RFAILED)
12026    {
12027       /*TODO : Negative case*/
12028       // BuildAndSendUeContextSetupRsp(cellId,ueId);
12029       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
12030    }
12031    else
12032       ret = duProcUeContextSetupRequest(duUeCb);
12033
12034    freeAperDecodeF1UeContextSetupReq(ueSetReq);
12035    return ret;
12036
12037 }
12038 /*******************************************************************
12039  * @brief Free the memory allocated for Dl Tunnel Info
12040  *
12041  * @details
12042  *
12043  *    Function : freeDlTnlInfo
12044  *
12045  *    Functionality:
12046  *       Free the memory allocated for Dl Tunnel Info
12047  *
12048  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
12049  * @return void
12050  *
12051  * ****************************************************************/
12052
12053 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
12054 {
12055    uint8_t arrIdx = 0;
12056
12057    if(tnlInfo)
12058    {
12059       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
12060       {
12061          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
12062                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
12063          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
12064                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
12065          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
12066          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
12067       }
12068       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
12069    }
12070 }
12071
12072 /*******************************************************************
12073  * @brief Free the memory allocated for DRB setup List
12074  *
12075  * @details
12076  *
12077  *    Function : freeDrbSetupList
12078  *
12079  *    Functionality:
12080  *       Free the memory allocated for DRB setup list
12081  *
12082  * @params[in] DRBs_Setup_List_t *
12083  * @return void
12084  *
12085  * ****************************************************************/
12086 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
12087 {
12088    uint8_t arrIdx = 0;
12089    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
12090
12091    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12092    {
12093       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12094       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
12095       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
12096    }
12097    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12098 }
12099
12100 /*******************************************************************
12101  * @brief Free the memory allocated for UE Setup response
12102  *
12103  * @details
12104  *
12105  *    Function : FreeUeContextSetupRsp
12106  *
12107  *    Functionality:
12108  *       Free the memory allocated for UE Setup response
12109  *
12110  * @params[in] F1AP PDU for UE setup response
12111  * @return ROK     - success
12112  *         RFAILED - failure
12113  *
12114  * ****************************************************************/
12115 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
12116 {
12117    uint8_t idx;
12118    UEContextSetupResponse_t *ueSetRsp = NULLP;
12119
12120    if(f1apMsg)
12121    {
12122       if(f1apMsg->choice.successfulOutcome)
12123       {
12124          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
12125                     UEContextSetupResponse;
12126          if(ueSetRsp->protocolIEs.list.array)
12127          {
12128             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
12129             {
12130                if(ueSetRsp->protocolIEs.list.array[idx])
12131                {
12132                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
12133                   {
12134                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12135                         break;
12136                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12137                         break;
12138                      case ProtocolIE_ID_id_DUtoCURRCInformation:
12139                         {
12140                            CellGroupConfig_t *cellGrpCfg = NULLP;
12141                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
12142                                          DUtoCURRCInformation.cellGroupConfig;
12143                            if(cellGrpCfg->buf != NULLP)
12144                            {
12145                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
12146                               cellGrpCfg = NULLP;
12147                            }
12148                            break;
12149                         }
12150                     case ProtocolIE_ID_id_DRBs_Setup_List:
12151                         {
12152                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
12153                            break;
12154                         }
12155                      default:
12156                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
12157                         ueSetRsp->protocolIEs.list.array[idx]->id);
12158                         break;
12159                   }
12160                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
12161                         sizeof(UEContextSetupResponseIEs_t));
12162                }
12163             }
12164             DU_FREE(ueSetRsp->protocolIEs.list.array, \
12165                   ueSetRsp->protocolIEs.list.size);
12166          }
12167          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12168       }
12169       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12170    }
12171 }
12172
12173 /*******************************************************************
12174  *
12175  * @brief Builds Ue context Setup Rsp DU To CU Info
12176  *
12177  * @details
12178  *
12179  *    Function : EncodeUeCntxtDuToCuInfo
12180  *
12181  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
12182  *
12183  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
12184  *
12185  * @return ROK     - success
12186  *         RFAILED - failure
12187  *
12188  ******************************************************************/
12189
12190 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
12191 {
12192    asn_enc_rval_t        encRetVal;
12193
12194    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
12195    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
12196    encBufSize = 0;
12197    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
12198    /* Encode results */
12199    if(encRetVal.encoded == ENCODE_FAIL)
12200    {
12201       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
12202             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12203       return RFAILED;
12204    }
12205    else
12206    {
12207       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
12208       for(int i=0; i< encBufSize; i++)
12209       {
12210          printf("%x",encBuf[i]);
12211       }
12212    }
12213    duToCuCellGrp->size = encBufSize;
12214    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
12215    if(!duToCuCellGrp->buf)
12216    {
12217       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
12218    }
12219    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
12220    return ROK;
12221 }
12222
12223 /*******************************************************************
12224  *
12225  * @brief Fills Dl Gtp tunnel Info
12226  *
12227  * @details
12228  *
12229  *    Function : fillGtpTunnelforDl
12230  *
12231  *    Functionality: Fills Dl Gtp tunnel Info
12232  *
12233  * @params[in]
12234  *
12235  * @return ROK     - success
12236  *         RFAILED - failure
12237  *
12238  * ****************************************************************/
12239
12240 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
12241 {
12242    uint8_t bufSize = 0;
12243
12244    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
12245    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
12246    if(gtpDl->transportLayerAddress.buf == NULLP)
12247    {
12248       return RFAILED;
12249    }
12250    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
12251
12252    /*GTP TEID*/
12253    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
12254    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
12255    if(gtpDl->gTP_TEID.buf == NULLP)
12256    {
12257       return RFAILED;
12258    }
12259    bufSize = 3; /*forming an Octect String*/
12260    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
12261
12262    return ROK;
12263 }
12264
12265 /*******************************************************************
12266  *
12267  * @brief Fills DL Tunnel Setup List
12268  *
12269  * @details
12270  *
12271  *    Function : fillDlTnlSetupList
12272  *
12273  *    Functionality: Fills the DL Tunnel Setup List
12274  *
12275  * @params[in]
12276  *
12277  * @return ROK     - success
12278  *         RFAILED - failure
12279  *
12280  * ****************************************************************/
12281
12282 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
12283 {
12284    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
12285
12286    eleCount = 1;
12287    dlTnlInfo->list.count = eleCount;
12288    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
12289
12290    /* Initialize the DL Tnl Setup List Members */
12291    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
12292    if(dlTnlInfo->list.array == NULLP)
12293    {
12294       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
12295       ret = RFAILED;
12296    }
12297    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
12298    {
12299       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
12300       if(dlTnlInfo->list.array[arrIdx] == NULLP)
12301       {
12302          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
12303          return RFAILED;
12304       }
12305       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
12306       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
12307       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
12308       {
12309          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
12310          return RFAILED;
12311       }
12312       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
12313                tnlCfg->tnlCfg1);
12314       if(ret != ROK)
12315          break;
12316    }
12317    return ret;
12318 }
12319
12320 /*******************************************************************
12321  *
12322  * @brief Fills the Drb Setup List for Ue Context Setup Response
12323  *
12324  * @details
12325  *
12326  *    Function : fillDrbSetupList
12327  *
12328  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
12329  *
12330  * @params[in]
12331  *
12332  * @return ROK     - success
12333  *         RFAILED - failure
12334  *
12335  * ****************************************************************/
12336 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
12337 {
12338    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
12339    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
12340
12341    eleCount = ueCfg->numDrb;
12342    drbSetupList->list.count = eleCount;
12343    drbSetupList->list.size = \
12344         (eleCount * sizeof(DRBs_Setup_Item_t *));
12345
12346    /* Initialize the Drb Setup List Members */
12347    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
12348    if(drbSetupList->list.array == NULLP)
12349    {
12350       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
12351       ret = RFAILED;
12352    }
12353
12354    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
12355    {
12356       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
12357       if(drbSetupList->list.array[arrIdx] == NULLP)
12358       {
12359          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
12360          return RFAILED;
12361       }
12362       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12363       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
12364       drbItemIe->criticality = Criticality_reject;
12365       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
12366       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12367       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
12368           &ueCfg->upTnlInfo[arrIdx]);
12369       if(ret != ROK)
12370          break;
12371    }
12372    return ret;
12373 }
12374
12375 /*******************************************************************
12376  *
12377  * @brief Builds and sends the UE Setup Response
12378  *
12379  * @details
12380  *
12381  *    Function : BuildAndSendUeContextSetupRsp
12382  *
12383  *    Functionality: Constructs the UE Setup Response and sends
12384  *                   it to the DU through SCTP.
12385  *
12386  * @params[in] uint8_t cellId,uint8_t ueId
12387  *
12388  * @return ROK     - success
12389  *         RFAILED - failure
12390  *
12391  * ****************************************************************/
12392 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
12393 {
12394    uint8_t   idx, ret, cellIdx, elementCnt;
12395    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12396    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12397    asn_enc_rval_t  encRetVal;        /* Encoder return value */
12398    F1AP_PDU_t               *f1apMsg = NULLP;
12399    UEContextSetupResponse_t *ueSetRsp = NULLP;
12400    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
12401    DuUeCb                   *ueCb = NULLP;
12402
12403    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
12404
12405    while(true)
12406    {
12407       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12408       if(f1apMsg == NULLP)
12409       {
12410          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12411          ret = RFAILED;
12412          break;
12413       }
12414
12415       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
12416       DU_ALLOC(f1apMsg->choice.successfulOutcome,
12417             sizeof(SuccessfulOutcome_t));
12418       if(f1apMsg->choice.successfulOutcome == NULLP)
12419       {
12420          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
12421          ret = RFAILED;
12422          break;
12423       }
12424
12425       f1apMsg->choice.successfulOutcome->procedureCode = \
12426                                                          ProcedureCode_id_UEContextSetup;
12427       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12428       f1apMsg->choice.successfulOutcome->value.present = \
12429                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
12430
12431       ueSetRsp =
12432          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
12433       elementCnt = 4;
12434       ueSetRsp->protocolIEs.list.count = elementCnt;
12435       ueSetRsp->protocolIEs.list.size = \
12436                                         elementCnt * sizeof(UEContextSetupResponse_t *);
12437
12438       /* Initialize the UESetup members */
12439       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
12440             ueSetRsp->protocolIEs.list.size);
12441       if(ueSetRsp->protocolIEs.list.array == NULLP)
12442       {
12443          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
12444          ret = RFAILED;
12445          break;
12446       }
12447
12448       for(idx=0; idx<elementCnt; idx++)
12449       {
12450          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
12451                sizeof(UEContextSetupResponseIEs_t));
12452          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
12453          {
12454             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
12455             ret = RFAILED;
12456             break;
12457          }
12458       }
12459       /* Fetching Ue Cb Info*/
12460       GET_CELL_IDX(cellId, cellIdx);
12461       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
12462       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
12463       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
12464
12465       idx = 0;
12466       /*GNB CU UE F1AP ID*/
12467       ueSetRsp->protocolIEs.list.array[idx]->id = \
12468                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12469       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12470       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
12471                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12472       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12473
12474       /*GNB DU UE F1AP ID*/
12475       idx++;
12476       ueSetRsp->protocolIEs.list.array[idx]->id = \
12477                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12478       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12479       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
12480                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12481       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12482
12483
12484       /*DUtoCURRC Information */
12485       idx++;
12486       ueSetRsp->protocolIEs.list.array[idx]->id  = \
12487                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
12488       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12489       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
12490                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
12491       BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
12492
12493       /* Drb Setup List */
12494       idx++;
12495       ueSetRsp->protocolIEs.list.array[idx]->id  = \
12496                                                    ProtocolIE_ID_id_DRBs_Setup_List;
12497       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12498       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
12499                                                             UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
12500       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
12501             &ueCb->f1UeDb->duUeCfg);
12502       if(ret == RFAILED)
12503       {
12504          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
12505          freeF1UeDb(ueCb->f1UeDb);
12506          ueCb->f1UeDb = NULLP;
12507          break;
12508       }
12509
12510       /* Free UeContext Db created during Ue context Req */
12511       freeF1UeDb(ueCb->f1UeDb);
12512       ueCb->f1UeDb = NULLP;
12513
12514       /* TODO: To send Drb list */
12515       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12516
12517       /* Encode the UE context setup response type as APER */
12518       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
12519       encBufSize = 0;
12520       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12521             encBuf);
12522       /* Encode results */
12523       if(encRetVal.encoded == ENCODE_FAIL)
12524       {
12525          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
12526                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12527          ret = RFAILED;
12528          break;
12529       }
12530       else
12531       {
12532          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
12533          for(int i=0; i< encBufSize; i++)
12534          {
12535             printf("%x",encBuf[i]);
12536          }
12537       }
12538
12539       /* Sending  msg  */
12540       if(sendF1APMsg()  != ROK)
12541       {
12542          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
12543          ret = RFAILED;
12544          break;
12545       }
12546       break;
12547    }
12548    FreeUeContextSetupRsp(f1apMsg);
12549    return ret;
12550 }/* End of BuildAndSendUeContextSetupRsp */
12551 /*******************************************************************
12552 *
12553 * @brief  Build And Send Ue Context Rsp
12554 *
12555 * @details
12556 *
12557 *    Function : BuildAndSendUeCtxtRsp
12558 *
12559 *    Functionality : Build And Send Ue Context Rsp
12560
12561 * @params[in]
12562 * @return sucess = ROK
12563 *         failure = RFAILED
12564 *
12565 * ****************************************************************/
12566 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
12567 {
12568    uint8_t cellIdx = 0, actionType = 0;
12569
12570    GET_CELL_IDX(cellId, cellIdx);
12571    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
12572
12573    switch(actionType)
12574    {
12575       case UE_CTXT_SETUP:
12576          {
12577             BuildAndSendUeContextSetupRsp(cellId,ueId);
12578             break;
12579          }
12580       case UE_CTXT_MOD:
12581          {
12582             BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1]);
12583             break;
12584          }
12585       default:
12586          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
12587          break;
12588
12589    }
12590    return ROK;
12591 }
12592
12593 /*******************************************************************
12594  *
12595  * @brief deallocating the memory of  F1reset msg
12596  *
12597  * @details
12598  *
12599  *    Function : FreeF1ResetReq
12600  *
12601  *    Functionality :
12602  *         - freeing memory of F1reset request msg
12603  *
12604  * @params[in]
12605  * @return void
12606  *
12607  *
12608  * ****************************************************************/
12609 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
12610 {
12611    uint8_t idx =0 ;
12612    Reset_t *f1ResetMsg;
12613
12614    if(f1apMsg)
12615    {
12616       if(f1apMsg->choice.initiatingMessage)
12617       {
12618          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
12619
12620          if(f1ResetMsg->protocolIEs.list.array)
12621          {
12622             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
12623             {
12624                if(f1ResetMsg->protocolIEs.list.array[idx])
12625                {
12626                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
12627                }
12628             }
12629             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
12630          }
12631          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12632       }
12633       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12634    }
12635 }
12636 /*******************************************************************
12637  *
12638  * @brief Build and Send F1reset request
12639  *
12640  * @details
12641  *
12642  *    Function : BuildAndSendF1ResetReq
12643  *
12644  *    Functionality:
12645  *         - Build and Send F1reset request msg
12646  *
12647  * @params[in]
12648  * @return ROK     - success
12649  *         RFAILED - failure
12650  *
12651  * ****************************************************************/
12652 uint8_t BuildAndSendF1ResetReq()
12653 {
12654    uint8_t          elementCnt=0;
12655    uint8_t          idx=0;
12656    uint8_t          ret= RFAILED;
12657    Reset_t          *f1ResetMsg = NULLP;
12658    F1AP_PDU_t       *f1apMsg = NULLP;
12659    asn_enc_rval_t   encRetVal;
12660    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
12661    do
12662    {
12663       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12664       if(f1apMsg == NULLP)
12665       {
12666          break;
12667       }
12668       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12669       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12670       if(f1apMsg->choice.initiatingMessage == NULLP)
12671       {
12672          break;
12673       }
12674       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
12675       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12676       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
12677
12678       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
12679
12680       elementCnt = 3;
12681       f1ResetMsg->protocolIEs.list.count = elementCnt;
12682       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
12683
12684       /* Initialize the F1Setup members */
12685       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
12686       if(f1ResetMsg->protocolIEs.list.array == NULLP)
12687       {
12688          break;
12689       }
12690       for(idx=0; idx<elementCnt; idx++)
12691       {
12692          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
12693          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
12694          {
12695             break;
12696          }
12697       }
12698
12699       /*TransactionID*/
12700       idx=0;
12701       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
12702       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12703       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
12704       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
12705
12706       /*Cause*/
12707       idx++;
12708       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
12709       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
12710       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
12711       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
12712       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
12713
12714       /*Reset Type*/
12715       idx++;
12716       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
12717       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12718       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
12719       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
12720       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
12721
12722       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12723
12724       /* Encode the F1SetupRequest type as APER */
12725       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12726       encBufSize = 0;
12727       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12728             encBuf);
12729
12730       /* Encode results */
12731       if(encRetVal.encoded == ENCODE_FAIL)
12732       {
12733          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
12734                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12735          break;
12736       }
12737       else
12738       {
12739          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
12740          for(idx=0; idx< encBufSize; idx++)
12741          {
12742             printf("%x",encBuf[idx]);
12743          }
12744       }
12745
12746       if(sendF1APMsg() != ROK)
12747       {
12748          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
12749          break;
12750       }
12751
12752       ret = ROK;
12753       break;
12754    }while(true);
12755
12756    FreeF1ResetReq(f1apMsg);
12757    return ret;
12758 }
12759 /*******************************************************************
12760  *
12761  * @brief Build And Send F1ResetAck
12762  *
12763  * @details
12764  *
12765  *    Function : BuildAndSendF1ResetAck
12766  *
12767  *    Functionality:
12768  *         - Build And Send  F1ResetRSP
12769  *
12770  * @return ROK     - success
12771  *         RFAILED - failure
12772  *
12773  * ****************************************************************/
12774 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
12775 {
12776    uint8_t idx;
12777    ResetAcknowledge_t *f1ResetAck;
12778
12779    if(f1apMsg)
12780    {
12781       if(f1apMsg->choice.successfulOutcome)
12782       {
12783          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
12784
12785          if(f1ResetAck->protocolIEs.list.array)
12786          {
12787             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
12788             {
12789                if(f1ResetAck->protocolIEs.list.array[idx])
12790                {
12791                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
12792                }
12793             }
12794             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
12795          }
12796          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12797       }
12798       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12799    }
12800 }
12801
12802 /*******************************************************************
12803  *
12804  * @brief Build And Send F1ResetAck
12805  *
12806  * @details
12807  *
12808  *    Function : BuildAndSendF1ResetAck
12809  *
12810  *    Functionality:
12811  *         - Build And Send  F1ResetRSP
12812  *
12813  *  @params[in]
12814  * @return ROK     - success
12815  *         RFAILED - failure
12816  *
12817  * ****************************************************************/
12818 uint8_t BuildAndSendF1ResetAck()
12819 {
12820    uint8_t                idx = 0;
12821    uint8_t                elementCnt = 0;
12822    uint8_t                ret = RFAILED;
12823    F1AP_PDU_t             *f1apMsg = NULL;
12824    ResetAcknowledge_t     *f1ResetAck = NULLP;
12825    asn_enc_rval_t         encRetVal;
12826    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
12827
12828    do{
12829       /* Allocate the memory for F1ResetRequest_t */
12830       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12831       if(f1apMsg == NULLP)
12832       {
12833          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12834          break;
12835       }
12836
12837       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12838
12839       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12840       if(f1apMsg->choice.successfulOutcome == NULLP)
12841       {
12842          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12843          break;
12844       }
12845       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
12846       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
12847       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
12848
12849       elementCnt = 1;
12850
12851       f1ResetAck->protocolIEs.list.count = elementCnt;
12852       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
12853
12854       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
12855       if(f1ResetAck->protocolIEs.list.array == NULLP)
12856       {
12857          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
12858          break;
12859       }
12860
12861       for(idx=0; idx<elementCnt; idx++)
12862       {
12863          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
12864          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
12865          {
12866             break;
12867          }
12868       }
12869       /*TransactionID*/
12870       idx = 0;
12871       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
12872       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12873       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
12874       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
12875
12876       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12877
12878       /* Encode the F1SetupRequest type as UPER */
12879       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12880       encBufSize = 0;
12881       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
12882
12883       /* Check encode results */
12884       if(encRetVal.encoded == ENCODE_FAIL)
12885       {
12886          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
12887                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12888          break;
12889       }
12890       else
12891       {
12892          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
12893          for(int i=0; i< encBufSize; i++)
12894          {
12895             printf("%x",encBuf[i]);
12896          }
12897       }
12898       /* Sending msg */
12899       if(sendF1APMsg() != ROK)
12900       {
12901          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
12902          break;
12903       }
12904
12905       ret = ROK;
12906       break;
12907    }while(true);
12908
12909    FreeF1ResetAck(f1apMsg);
12910    return ret;
12911 }
12912 /******************************************************************
12913 *
12914 * @brief free F1 reset msg allocated by aper_decoder
12915 *
12916 * @details
12917 *
12918 *    Function : freeAperDecodeF1ResetMsg
12919 *
12920 *    Functionality: free F1 reset msg allocated by aper_decoder
12921 *
12922 * @params[in] Reset_t *f1ResetMsg
12923 * @return void
12924 *
12925 * ****************************************************************/
12926
12927 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
12928 {
12929    uint8_t ieIdx =0;
12930    if(f1ResetMsg->protocolIEs.list.array)
12931    {
12932       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
12933       {
12934          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
12935          {
12936             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
12937          }
12938       }
12939       free(f1ResetMsg->protocolIEs.list.array);
12940    }
12941 }
12942
12943 /******************************************************************
12944  *
12945  * @brief Processes DL RRC Message Transfer  sent by CU
12946  *
12947  * @details
12948  *
12949  *    Function : procF1ResetReq
12950  *
12951  *    Functionality: Processes DL RRC Message Transfer sent by CU
12952  *
12953  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12954  * @return ROK     - success
12955  *         RFAILED - failure
12956  *
12957  * ****************************************************************/
12958 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
12959 {
12960    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
12961    uint8_t       ieIdx = 0;
12962    uint8_t        ret = ROK;
12963    Reset_t       *f1ResetMsg = NULLP;
12964
12965    DU_LOG("\nINFO   -->  Processing F1 reset request");
12966    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
12967
12968    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
12969    {
12970       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
12971       {
12972          case ProtocolIE_ID_id_TransactionID:
12973             break;
12974
12975          case ProtocolIE_ID_id_Cause:
12976             break;
12977
12978          case ProtocolIE_ID_id_ResetType:
12979             {
12980                break;
12981             }
12982
12983          default:
12984             break;
12985       }
12986    }
12987    ret = BuildAndSendF1ResetAck();
12988    DU_LOG("\nINFO   -->  UE release is not supported for now");
12989
12990    freeAperDecodeF1ResetMsg(f1ResetMsg);
12991
12992    return ret;
12993 }
12994
12995 /*******************************************************************
12996  *
12997  * @brief free the RRC delivery report
12998  *
12999  * @details
13000  *
13001  *    Function : freeRrcDeliveryReport
13002  *
13003  *    Functionality: free the RRC delivery report
13004  *
13005  * @params[in]
13006  * @return ROK     - success
13007  *         RFAILED - failure
13008  *
13009  * ****************************************************************/
13010 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
13011 {
13012    uint8_t idx=0;
13013    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
13014
13015    if(f1apMsg)
13016    {
13017       if(f1apMsg->choice.initiatingMessage)
13018       {
13019          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
13020          if(rrcDeliveryReport->protocolIEs.list.array)
13021          {
13022             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
13023                   idx++)
13024             {
13025                if(rrcDeliveryReport->protocolIEs.list.array[idx])
13026                {
13027                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
13028                         sizeof(RRCDeliveryReportIEs_t));
13029                }
13030             }
13031             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
13032                   rrcDeliveryReport->protocolIEs.list.size);
13033          }
13034          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
13035       }
13036       DU_FREE(f1apMsg,
13037             sizeof(F1AP_PDU_t));
13038    }
13039 }
13040
13041 /*******************************************************************
13042 *
13043 * @brief Builds and sends the RRC delivery report
13044 *
13045 * @details
13046 *
13047 *    Function : BuildAndSendRrcDeliveryReport
13048 *
13049 *    Functionality: Builds and sends the RRC delivery report
13050 *
13051 * @params[in]
13052 *
13053 * @return ROK     - success
13054 *         RFAILED - failure
13055 *
13056 * ****************************************************************/
13057 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
13058    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
13059 {
13060    uint8_t             ret = RFAILED;
13061    uint8_t             idx    = 0;
13062    uint8_t             idx1   = 0;
13063    uint8_t             elementCnt = 0;
13064    F1AP_PDU_t          *f1apMsg = NULLP;
13065    asn_enc_rval_t      encRetVal;
13066    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
13067
13068    do{
13069
13070       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
13071       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13072       if(f1apMsg == NULLP)
13073       {
13074          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
13075          break;
13076       }
13077       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13078       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
13079       if(f1apMsg->choice.initiatingMessage == NULLP)
13080       {
13081          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
13082          break;
13083       }
13084       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
13085       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
13086       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
13087
13088       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
13089       elementCnt = 4;
13090       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
13091       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
13092
13093       /* Initialize the F1Setup members */
13094       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
13095       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
13096       {
13097          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
13098          break;
13099       }
13100       for(idx =0 ;idx <elementCnt; idx++)
13101       {
13102          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
13103          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
13104          {
13105             break;
13106          }
13107       }
13108
13109       idx1 = 0;
13110
13111       /*GNB CU UE F1AP ID*/
13112       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13113       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
13114       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
13115       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
13116
13117       /*GNB DU UE F1AP ID*/
13118       idx1++;
13119       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13120       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
13121       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
13122       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
13123
13124       /*RRC delivery status*/
13125       idx1++;
13126       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
13127       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
13128       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
13129       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
13130       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
13131       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
13132       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
13133
13134       /* SRB ID */
13135       idx1++;
13136       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
13137       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
13138       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
13139       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
13140
13141       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13142
13143       /* Encode the RRC DELIVERY REPORT type as APER */
13144       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13145       encBufSize = 0;
13146       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
13147             encBuf);
13148
13149       /* Encode results */
13150       if(encRetVal.encoded == ENCODE_FAIL)
13151       {
13152          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
13153                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13154          break;
13155       }
13156       else
13157       {
13158          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
13159          for(idx=0; idx< encBufSize; idx++)
13160          {
13161             printf("%x",encBuf[idx]);
13162          }
13163       }
13164
13165       /* Sending msg */
13166       if(sendF1APMsg() != ROK)
13167       {
13168          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
13169          break;
13170       }
13171       ret = ROK;
13172       break;
13173
13174    }while(true);
13175
13176    freeRrcDeliveryReport(f1apMsg);
13177    return ret;
13178 }
13179
13180 /*******************************************************************
13181  *
13182  * @brief Processes cells to be activated
13183  *
13184  * @details
13185  *
13186  *    Function : extractCellsToBeActivated
13187  *
13188  *    Functionality:
13189  *      - Processes cells to be activated list received in F1SetupRsp
13190  *
13191  * @params[in] void
13192  * @return ROK     - success
13193  *         RFAILED - failure
13194  *
13195  * ****************************************************************/
13196
13197 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
13198 {
13199    uint8_t  ret = ROK;
13200    uint16_t idx, nci, pci = 0;
13201    Cells_to_be_Activated_List_Item_t cell;
13202
13203    for(idx=0; idx<cellsToActivate.list.count; idx++)
13204    {
13205       nci = 0;
13206       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
13207       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
13208
13209       if(cell.nRPCI)
13210       {
13211          pci = *cell.nRPCI;
13212       }
13213       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
13214    }
13215    return ret;
13216 }
13217 /******************************************************************
13218 *
13219 * @brief Processes F1 Setup Response allocated by aper_decoder
13220 *
13221 * @details
13222 *
13223 *    Function : freeF1SetupRsp
13224 *
13225 *    Functionality: free F1 Setup Response allocated by aper_decoder
13226 *
13227 * @params[in] F1SetupResponse_t *f1SetRspMsg
13228 * @return void
13229 *
13230 * ****************************************************************/
13231
13232 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
13233 {
13234    uint8_t ieIdx =0;
13235    uint8_t arrIdx =0;
13236    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
13237    RRC_Version_t      *rrcVer =NULLP;
13238
13239    if(f1SetRspMsg->protocolIEs.list.array)
13240    {
13241       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
13242       {
13243          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
13244          {
13245             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
13246             {
13247                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
13248                   {
13249                      cellToActivate =
13250                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
13251                      if(cellToActivate->list.array)
13252                      {
13253                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
13254                         {
13255                            if(cellToActivate->list.array[arrIdx])
13256                            {
13257
13258                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
13259                               pLMN_Identity.buf)
13260                               {
13261                                  if(cellToActivate->list.array[0]->value.choice.\
13262                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
13263                                  {
13264                                     free(cellToActivate->list.array[0]->value.choice.\
13265                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
13266                                  }
13267
13268                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
13269                                        nRCGI.pLMN_Identity.buf);
13270                               }
13271                               free(cellToActivate->list.array[arrIdx]);
13272                            }
13273                         }
13274                         free(cellToActivate->list.array);
13275                      }
13276                      break;
13277                   }
13278                case ProtocolIE_ID_id_TransactionID:
13279                   {
13280                      break;
13281                   }
13282                case ProtocolIE_ID_id_gNB_CU_Name:
13283                   {
13284                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
13285                      break;
13286                   }
13287                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
13288                   {
13289                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
13290                      if(rrcVer->latest_RRC_Version.buf)
13291                      {
13292                         if(rrcVer->iE_Extensions)
13293                         {
13294                            if(rrcVer->iE_Extensions->list.array)
13295                            {
13296                               if(rrcVer->iE_Extensions->list.array[0])
13297                               {
13298                                  if(rrcVer->iE_Extensions->list.\
13299                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
13300                                  {
13301                                     free(rrcVer->iE_Extensions->list.\
13302                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
13303                                  }
13304                                  free(rrcVer->iE_Extensions->list.array[0]);
13305                               }
13306                               free(rrcVer->iE_Extensions->list.array);
13307                            }
13308                            free(rrcVer->iE_Extensions);
13309                         }
13310                         free(rrcVer->latest_RRC_Version.buf);
13311                      }
13312                      break;
13313
13314                   }
13315                default:
13316                   {
13317                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
13318                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
13319                   }
13320             }
13321             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
13322          }
13323       }
13324       free(f1SetRspMsg->protocolIEs.list.array);
13325    }
13326 }
13327 /******************************************************************
13328  *
13329  * @brief Processes F1 Setup Response sent by CU
13330  *
13331  * @details
13332  *
13333  *    Function : procF1SetupRsp
13334  *
13335  *    Functionality: Processes F1 Setup Response sent by CU
13336  *
13337  * @params[in] F1AP_PDU_t ASN decoded F1AP message
13338  * @return ROK     - success
13339  *         RFAILED - failure
13340  *
13341  * ****************************************************************/
13342 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
13343 {
13344    uint8_t ret = ROK;
13345    uint16_t idx =0;
13346    F1SetupResponse_t *f1SetRspMsg = NULLP;
13347    GNB_CU_Name_t     *cuName = NULLP;
13348    F1SetupRsp  f1SetRspDb;
13349    RRC_Version_t      *rrcVer =NULLP;
13350
13351    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
13352
13353    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
13354    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
13355
13356    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
13357    {
13358       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
13359       {
13360          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
13361             {
13362                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
13363                      value.choice.Cells_to_be_Activated_List);
13364                break;
13365             }
13366          case ProtocolIE_ID_id_TransactionID:
13367             {
13368                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
13369                                     value.choice.TransactionID;
13370                break;
13371             }
13372          case ProtocolIE_ID_id_gNB_CU_Name:
13373             {
13374                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
13375                         value.choice.GNB_CU_Name;
13376                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
13377                break;
13378             }
13379          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
13380             {
13381                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
13382                strcpy(f1SetRspDb.rrcVersion.rrcVer,
13383                      (const char*)rrcVer->latest_RRC_Version.buf);
13384                break;
13385             }
13386          default:
13387             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
13388                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
13389       }
13390       duProcF1SetupRsp();
13391    }
13392
13393    freeAperDecodeF1SetupRsp(f1SetRspMsg);
13394
13395    duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
13396    DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
13397    if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
13398    {
13399       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the buf of F1setup response");
13400       return RFAILED;
13401    }
13402    memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
13403
13404    if(BuildAndSendE2SetupReq() != ROK)
13405    {
13406       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
13407       return RFAILED;
13408    }
13409    return ret;
13410 }
13411 /*******************************************************************
13412 *
13413 * @brief free GNB DU config update ack
13414 *
13415 * @details
13416 *
13417 *    Function : freeAperDecodeGnbDuAck
13418 *
13419 *    Functionality: Processes GNB DU config update ack And
13420 *                     added free part for the memory allocated by aper_decoder
13421 *
13422 * @params[in] F1AP_PDU_t ASN decoded F1AP message
13423 * @return ROK     - success
13424 *         RFAILED - failure
13425 *
13426 * ****************************************************************/
13427
13428 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
13429 {
13430    uint8_t ieIdx = 0;
13431
13432    if(gnbDuAck->protocolIEs.list.array)
13433    {
13434       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
13435       {
13436          if(gnbDuAck->protocolIEs.list.array[ieIdx])
13437          {
13438             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
13439          }
13440       }
13441       free(gnbDuAck->protocolIEs.list.array);
13442    }
13443 }
13444
13445 /*******************************************************************
13446 *
13447 * @brief Building  result of gnb-du config update ack output
13448 *
13449 * @details
13450 *
13451 *    Function : duProcGnbDuCfgUpdAckMsg
13452 *
13453 *    Functionality:
13454 *        Building output of gnb-du config update ack
13455 *
13456 * @params[in] transId
13457 * @return void
13458 *
13459 * ****************************************************************/
13460
13461 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
13462 {
13463    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
13464    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
13465    uint16_t cellId =0, cellIdx =0, crnti=0;
13466    CmLList *f1apPduNode = NULLP;
13467    ReservedF1apPduInfo *f1apPduInfo =NULLP;
13468    F1AP_PDU_t *f1apMsgPdu = NULLP;
13469    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
13470    BIT_STRING_t *cellIdentity=NULLP;
13471    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
13472    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
13473    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
13474
13475    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
13476    f1apPduNode = searchFromReservedF1apPduList(transId);
13477    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
13478    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
13479
13480    if(f1apMsgPdu)
13481    {
13482       if(f1apMsgPdu->choice.initiatingMessage)
13483       {
13484          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
13485          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
13486          {
13487             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
13488             {
13489                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
13490                   {
13491                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
13492                                      Served_Cells_To_Delete_List;
13493                      if(cellsToDelete->list.array)
13494                      {
13495                         if(cellsToDelete->list.array[arrIdx])
13496                         {
13497                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
13498                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
13499                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
13500                            {
13501                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
13502                               bitStringToInt(cellIdentity, &cellId);
13503                            }
13504                         }
13505                      }
13506
13507                      GET_CELL_IDX(cellId, cellIdx);
13508                      if(duCb.actvCellLst[cellIdx] != NULLP)
13509                      {
13510                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
13511                         {
13512                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13513                            ret = duSendCellDeletReq(cellId);
13514                            if(ret == RFAILED)
13515                            {
13516                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
13517                               request for cellId[%d]", cellId);
13518                            }
13519                         }
13520                         else
13521                         {
13522                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
13523                            while(totalActiveUe)
13524                            {
13525                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
13526                               {
13527                                  ueIdx++;
13528                                  continue;
13529                               }
13530
13531                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
13532                               GET_UE_ID(crnti,ueId);
13533                               /* Sending Ue Context release request only for maximum supporting UEs */
13534                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
13535                               if(ret == RFAILED)
13536                               {
13537                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
13538                                  request for cellId[%d]", cellId);
13539                               }
13540                               ueIdx++;
13541                               totalActiveUe--;
13542                            }
13543                         }
13544                      }
13545                      else
13546                      {
13547                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
13548                         ret = RFAILED;
13549                      }
13550                      break;
13551                   }
13552
13553                default:
13554                   break;
13555             }
13556          }
13557       }
13558    }
13559
13560    FreeDUConfigUpdate(f1apMsgPdu);
13561    deleteFromReservedF1apPduList(f1apPduNode);
13562    return ret;
13563 }
13564
13565 /*******************************************************************
13566 *
13567 * @brief Processes GNB DU config update ack
13568 *
13569 * @details
13570 *
13571 *    Function : procF1GNBDUCfgUpdAck
13572 *
13573 *    Functionality: added free part for the memory allocated by aper_decoder
13574 *
13575 * @params[in] F1AP_PDU_t *f1apMsg
13576 * @return void
13577 *
13578 * ****************************************************************/
13579 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
13580 {
13581    uint8_t ieIdx=0,transId=0;
13582    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
13583
13584    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
13585    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
13586
13587    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
13588    {
13589       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
13590       {
13591          case ProtocolIE_ID_id_TransactionID:
13592             {
13593                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
13594                break;
13595             }
13596          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
13597             {
13598                break;
13599             }
13600          default :
13601             {
13602                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
13603                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
13604                break;
13605             }
13606       }
13607    }
13608
13609    duProcGnbDuCfgUpdAckMsg(transId);
13610
13611 #if 0
13612    /* presently we are not supporting F1 Reset from DU to CU , we are only
13613     * supporting F1 Reset from CU to DU */
13614
13615    if(BuildAndSendF1ResetReq() != ROK)
13616    {
13617       return RFAILED;
13618    }
13619 #endif
13620
13621    freeAperDecodeGnbDuAck(gnbDuAck);
13622    return ROK;
13623 }
13624 /******************************************************************
13625 *
13626 * @brief free DL RRC Message Transfer allocated by aper_decoder
13627 *
13628 * @details
13629 *
13630 *    Function : freeAperDecodef1DlRrcMsg
13631 *
13632 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
13633 *
13634 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
13635 * @return ROK     - success
13636 *         RFAILED - failure
13637 *
13638 * ****************************************************************/
13639
13640 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
13641 {
13642    uint8_t ieIdx =0;
13643    RRCContainer_t *rrcContainer = NULLP;
13644
13645    if(f1DlRrcMsg->protocolIEs.list.array)
13646    {
13647       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
13648       {
13649          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
13650          {
13651             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
13652             {
13653                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13654                   break;
13655                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13656                   break;
13657                case ProtocolIE_ID_id_SRBID:
13658                   break;
13659                case ProtocolIE_ID_id_RRCContainer:
13660                   {
13661                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
13662                      free(rrcContainer->buf);
13663                   }
13664                case ProtocolIE_ID_id_ExecuteDuplication:
13665                   break;
13666                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13667                   break;
13668                   break;
13669             }
13670             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
13671          }
13672       }
13673       free(f1DlRrcMsg->protocolIEs.list.array);
13674    }
13675 }
13676 /******************************************************************
13677  *
13678  * @brief Processes DL RRC Message Transfer  sent by CU
13679  *
13680  * @details
13681  *
13682  *    Function : procF1DlRrcMsgTrans
13683  *
13684  *    Functionality: Processes DL RRC Message Transfer sent by CU
13685  *
13686  * @params[in] F1AP_PDU_t ASN decoded F1AP message
13687  * @return ROK     - success
13688  *         RFAILED - failure
13689  *
13690  * ****************************************************************/
13691 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
13692 {
13693    uint8_t  idx, ret;
13694    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
13695    F1DlRrcMsg dlMsg;
13696    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
13697
13698    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
13699    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
13700
13701    ret = ROK;
13702
13703    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
13704    {
13705       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
13706       {
13707          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13708             {
13709                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
13710                break;
13711             }
13712          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13713             {
13714                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
13715                break;
13716             }
13717          case ProtocolIE_ID_id_SRBID:
13718             {
13719                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
13720                break;
13721             }
13722          case ProtocolIE_ID_id_ExecuteDuplication:
13723             dlMsg.execDup = true;
13724             break;
13725
13726          case ProtocolIE_ID_id_RRCContainer:
13727             {
13728                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
13729                {
13730                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
13731                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
13732                   if(dlMsg.rrcMsgPdu)
13733                   {
13734                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
13735                         dlMsg.rrcMsgSize);
13736                   }
13737                   else
13738                   {
13739                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
13740                      return RFAILED;
13741                   }
13742                }
13743                else
13744                {
13745                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
13746                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
13747                   return RFAILED;
13748                }
13749                break;
13750             }
13751          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13752             {
13753                dlMsg.deliveryStatRpt = true;
13754                break;
13755             }
13756          default:
13757             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
13758                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
13759       }
13760    }
13761
13762    ret = duProcDlRrcMsg(&dlMsg);
13763
13764    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
13765    return ret;
13766 }
13767 /*******************************************************************
13768  *
13769 * @brief Builds the DRB to be Setup Mod list
13770 *
13771 * @details
13772 *
13773 *    Function :
13774 *
13775 *    Functionality: Constructs the DRB to be Setup Mod list
13776 *
13777 * @params[in] DRBs_SetupMod_List_t *drbSet
13778 *
13779 * @return ROK     - success
13780 *         RFAILED - failure
13781 *
13782 * ****************************************************************/
13783 uint8_t BuildSrbSetupModList(SRBs_SetupMod_List_t *srbList, DuUeCfg *ueCfg)
13784 {
13785    uint8_t srbIdx = 0;
13786    struct SRBs_SetupMod_ItemIEs *srbItemIe;
13787
13788    srbList->list.count = ueCfg->numRlcLcs;
13789    srbList->list.size = srbList->list.count * sizeof(SRBs_SetupMod_ItemIEs_t *);
13790
13791    DU_ALLOC(srbList->list.array, srbList->list.size);
13792    if(srbList->list.array == NULLP)
13793    {
13794       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
13795       return RFAILED;
13796    }
13797
13798    for(srbIdx = 0; srbIdx < srbList->list.count; srbIdx++)
13799    {
13800       DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
13801       if(srbList->list.array[srbIdx] == NULLP)
13802       {
13803          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
13804          return RFAILED;
13805       }
13806    }
13807
13808    for(srbIdx=0; srbIdx < srbList->list.count; srbIdx++)
13809    {
13810       srbItemIe = (struct SRBs_SetupMod_ItemIEs *)srbList->list.array[srbIdx];
13811       srbItemIe->id = ProtocolIE_ID_id_SRBs_SetupMod_Item;
13812       srbItemIe->criticality = Criticality_reject;
13813       srbItemIe->value.present = SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item;
13814       srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID = ueCfg->rlcLcCfg[srbIdx].rbId;
13815       srbItemIe->value.choice.SRBs_SetupMod_Item.lCID = ueCfg->rlcLcCfg[srbIdx].lcId;
13816    }
13817    return ROK;
13818 }
13819
13820 /*******************************************************************
13821  *
13822 * @brief Builds the DRB to be Setup Mod list
13823 *
13824 * @details
13825 *
13826 *    Function :
13827 *
13828 *    Functionality: Constructs the DRB to be Setup Mod list
13829 *
13830 * @params[in] DRBs_SetupMod_List_t *drbSet
13831 *
13832 * @return ROK     - success
13833 *         RFAILED - failure
13834 *
13835 * ****************************************************************/
13836
13837 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
13838 {
13839    uint8_t arrIdx =0;
13840    uint8_t drbCnt =0;
13841    struct DRBs_SetupMod_ItemIEs *drbItemIe;
13842
13843    drbCnt = ueCfg->numDrbSetupMod;
13844    drbSet->list.count = drbCnt;
13845    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
13846    DU_ALLOC(drbSet->list.array, drbSet->list.size);
13847    if(drbSet->list.array == NULLP)
13848    {
13849       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
13850       return  RFAILED;
13851    }
13852    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
13853    {
13854       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
13855       if(drbSet->list.array[arrIdx] == NULLP)
13856       {
13857               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
13858               return  RFAILED;
13859       }
13860
13861       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
13862       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
13863       drbItemIe->criticality = Criticality_reject;
13864       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
13865       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
13866       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
13867       &ueCfg->upTnlInfo[arrIdx])!= ROK)
13868       {
13869          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
13870          return RFAILED;
13871       }
13872
13873    }
13874
13875    return ROK;
13876 }
13877 /*******************************************************************
13878 * @brief Free the memory allocated for DRB setup List
13879 *
13880 * @details
13881 *
13882 *    Function : FreeDrbSetupModList
13883 *
13884 *    Functionality:
13885 *       Free the memory allocated for DRB setup list
13886 *
13887 * @params[in] DRBs_Setup_List_t *
13888 * @return void
13889 *
13890 * ****************************************************************/
13891 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
13892 {
13893    uint8_t arrIdx = 0;
13894    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
13895
13896    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
13897    {
13898       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
13899       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
13900       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
13901    }
13902    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
13903 }
13904
13905 /*******************************************************************
13906 * @brief Free the memory allocated for SRB setup List
13907 *
13908 * @details
13909 *
13910 *    Function : FreeSrbSetupModList
13911 *
13912 *    Functionality:
13913 *       Free the memory allocated for SRB setup list
13914 *
13915 * @params[in] SRBs_Setup_List_t *
13916 * @return void
13917 *
13918 * ****************************************************************/
13919 void FreeSrbSetupModList(SRBs_SetupMod_List_t *srbSetupList)
13920 {
13921    uint8_t srbIdx = 0;
13922
13923    for(srbIdx = 0; srbIdx < srbSetupList->list.count; srbIdx++)
13924       DU_FREE(srbSetupList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
13925    DU_FREE(srbSetupList->list.array, srbSetupList->list.size);
13926 }
13927
13928 /*******************************************************************
13929 * @brief Free the memory allocated for UE Context Mod Response
13930 *
13931 * @details
13932 *
13933 *    Function : FreeUeContextModResp
13934 *
13935 *    Functionality:
13936 *       Free the memory allocated for UE Context Mod Response
13937 *
13938 * @params[in] F1AP_PDU_t *f1apMsg
13939 * @return void
13940 *
13941 * ****************************************************************/
13942
13943 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
13944 {
13945    uint8_t ieIdx;
13946    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
13947    if(f1apMsg)
13948    {
13949       if(f1apMsg->choice.successfulOutcome)
13950       {
13951          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
13952          if(ueContextModifyRes->protocolIEs.list.array)
13953          {
13954             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
13955             {
13956                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
13957                {
13958                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
13959                   {
13960                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13961                         break;
13962                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13963                         break;
13964                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
13965                         {
13966                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
13967                             value.choice.DRBs_SetupMod_List));
13968                             break;
13969                         }
13970                      case ProtocolIE_ID_id_SRBs_SetupMod_List:
13971                         {
13972                            FreeSrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
13973                               SRBs_SetupMod_List));
13974                            break;
13975                         }
13976                   }
13977                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
13978                }
13979
13980             }
13981             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
13982          }
13983          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13984       }
13985       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13986    }
13987 }
13988
13989 /*****************************************************************i
13990 *
13991 * @brief Creating the ue context modifcation response and sending
13992 *
13993 * @details
13994 *
13995 *    Function : BuildAndSendUeContextModRsp
13996 *
13997 *    Functionality:
13998 *         - Creating the ue context modifcation response
13999 *
14000 * @params[in] uint8_t cellId,uint8_t ueId
14001 * @return ROK     - success
14002 *         RFAILED - failure
14003 *
14004 * ****************************************************************/
14005 uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb)
14006 {
14007    uint8_t   ieIdx = 0, tnlIdx = 0, rbIdx = 0;
14008    uint8_t   elementCnt = 0;
14009    uint8_t   ret = RFAILED;
14010    F1AP_PDU_t *f1apMsg = NULLP;
14011    asn_enc_rval_t  encRetVal;
14012    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
14013
14014    DU_LOG("\nINFO  -->  F1AP : Building UE context modification response\n");
14015
14016    while(1)
14017    {
14018       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14019       if(f1apMsg == NULLP)
14020       {
14021          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
14022          break;
14023       }
14024
14025       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
14026
14027       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14028       if(f1apMsg->choice.successfulOutcome == NULLP)
14029       {
14030          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
14031          break;
14032       }
14033       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
14034       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
14035       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
14036
14037       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
14038
14039       if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
14040          elementCnt = 3;
14041       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14042          elementCnt = 5;
14043       if(ueCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE)
14044          elementCnt = 2;
14045       ueContextModifyRes->protocolIEs.list.count = elementCnt;
14046       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
14047
14048       /* Initialize the UE context modification members */
14049       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
14050       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
14051       {
14052          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
14053          break;
14054       }
14055
14056       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
14057       {
14058          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
14059          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
14060          {
14061             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
14062             break;
14063          }
14064       }
14065
14066       ieIdx=0;
14067       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14068       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14069       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
14070       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
14071       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
14072
14073       ieIdx++;
14074       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14075       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14076       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
14077       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
14078       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
14079
14080       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14081       {
14082          ieIdx++;
14083          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCInformation;
14084          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14085          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
14086          UEContextModificationResponseIEs__value_PR_DUtoCURRCInformation;
14087          BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
14088       }
14089
14090       if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || (ueCb->f1UeDb->actionType == UE_CTXT_MOD))
14091       {
14092          ieIdx++;
14093          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
14094          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14095          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
14096                                                                            UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
14097          if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14098          {
14099             for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
14100             {
14101                if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
14102                {
14103                   memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
14104                }
14105             }
14106          }
14107          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
14108                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
14109          if(ret != ROK)
14110          {
14111             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB setupmod List ");
14112             break;
14113          }
14114       }
14115
14116       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14117       {
14118          ieIdx++;
14119          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_SRBs_SetupMod_List;
14120          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14121          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
14122                                                                             UEContextModificationResponseIEs__value_PR_SRBs_SetupMod_List;
14123          for(rbIdx = 0; rbIdx < ueCb->rlcUeCfg.numLcs; rbIdx++)
14124          {
14125             if(ueCb->rlcUeCfg.rlcLcCfg[rbIdx].rbType == RB_TYPE_SRB)
14126             {
14127                memcpy(&ueCb->f1UeDb->duUeCfg.rlcLcCfg[ueCb->f1UeDb->duUeCfg.numRlcLcs++], &ueCb->rlcUeCfg.rlcLcCfg[rbIdx],\
14128                      sizeof(RlcBearerCfg));
14129             }
14130          }
14131          ret = BuildSrbSetupModList(&ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.SRBs_SetupMod_List, \
14132                &ueCb->f1UeDb->duUeCfg);
14133          if(ret != ROK)
14134          {
14135             DU_LOG( "\nERROR  -->  F1AP : Failed to build SRB setupmod List ");
14136             break;
14137          }
14138       }
14139
14140       freeF1UeDb(ueCb->f1UeDb);
14141       ueCb->f1UeDb = NULLP;
14142
14143       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14144
14145       /* Encode the F1SetupRequest type as APER */
14146       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14147       encBufSize = 0;
14148       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
14149
14150       /* Encode results */
14151       if(encRetVal.encoded == ENCODE_FAIL)
14152       {
14153          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
14154                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14155          ret = RFAILED;
14156          break;
14157       }
14158       else
14159       {
14160          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
14161          for(int i=0; i< encBufSize; i++)
14162          {
14163             printf("%x",encBuf[i]);
14164          }
14165       }
14166
14167       /* Sending  msg  */
14168       if(sendF1APMsg() != ROK)
14169       {
14170          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
14171          ret = RFAILED;
14172          break;
14173       }
14174       break;
14175    }
14176    FreeUeContextModResp(f1apMsg);
14177    return ret;
14178 }
14179 /*******************************************************************
14180  *
14181  * @brief Deallocating the memory allocated by the aper decoder
14182  *          for QOSInfo
14183  *
14184  * @details
14185  *
14186  *    Function : freeAperDecodeQosInfo
14187  *
14188  *    Functionality:  Deallocating the memory allocated for QOSInfo
14189  *
14190  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
14191  *
14192  * @return void
14193  *
14194  * ****************************************************************/
14195
14196 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
14197 {
14198    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
14199    {
14200       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
14201       {
14202          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
14203          {
14204             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
14205          }
14206          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
14207       }
14208       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
14209    }
14210 }
14211 /*******************************************************************
14212  *
14213  * @brief Deallocating the memory allocated by the aper decoder
14214  *          for UlTnlInfoforDrb
14215  *
14216  * @details
14217  *
14218  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
14219  *
14220  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
14221  *
14222  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
14223  *
14224  * @return void
14225  *
14226  * ****************************************************************/
14227 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
14228 {
14229    uint8_t arrIdx =0;
14230
14231    if(ulInfo->list.array)
14232    {
14233       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
14234       {
14235          if(ulInfo->list.array[arrIdx])
14236          {
14237             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
14238             {
14239                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
14240                {
14241                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
14242                   {
14243                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
14244                            gTP_TEID.buf);
14245                   }
14246                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
14247                         transportLayerAddress.buf);
14248                }
14249                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
14250             }
14251             free(ulInfo->list.array[arrIdx]);
14252          }
14253       }
14254       free(ulInfo->list.array);
14255    }
14256 }
14257 /*******************************************************************
14258  *
14259  * @brief Deallocating the memory allocated by the aper decoder
14260  *          for DrbSetupModItem
14261  *
14262  * @details
14263  *
14264  *    Function : freeAperDecodeDrbSetupModItem
14265  *
14266  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
14267  *
14268  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
14269  *
14270  * @return void
14271  *
14272  * ****************************************************************/
14273
14274 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
14275 {
14276    uint8_t arrIdx =0;
14277    SNSSAI_t *snssai =NULLP;
14278    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
14279
14280    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
14281    switch(drbItem->qoSInformation.present)
14282    {
14283       case QoSInformation_PR_NOTHING:
14284          break;
14285       case QoSInformation_PR_eUTRANQoS:
14286          {
14287             if(drbItem->qoSInformation.choice.eUTRANQoS)
14288             {
14289                free(drbItem->qoSInformation.choice.eUTRANQoS);
14290             }
14291             break;
14292          }
14293       case QoSInformation_PR_choice_extension:
14294          {
14295             if(drbItem->qoSInformation.choice.choice_extension)
14296             {
14297                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
14298                      DRB_Information.dRB_QoS);
14299                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
14300                if(snssai->sST.buf)
14301                {
14302                   free(snssai->sST.buf);
14303                }
14304                if(snssai->sD)
14305                {
14306                   if(snssai->sD->buf)
14307                   {
14308                      free(snssai->sD->buf);
14309                   }
14310                   free(snssai->sD);
14311                }
14312
14313                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
14314                          DRB_Information.flows_Mapped_To_DRB_List;
14315                if(flowMap->list.array)
14316                {
14317                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
14318                   {
14319                      if(flowMap->list.array[arrIdx] )
14320                      {
14321                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
14322                         free(flowMap->list.array[arrIdx]);
14323                      }
14324                   }
14325                   free(flowMap->list.array);
14326                }
14327
14328                free(drbItem->qoSInformation.choice.choice_extension);
14329             }
14330             break;
14331          }
14332
14333    }
14334    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
14335    if(drbItem->uLConfiguration)
14336    {
14337       free(drbItem->uLConfiguration);
14338    }
14339 }
14340
14341 /*******************************************************************
14342  *
14343  * @brief Deallocating the memory allocated by the aper decoder
14344  *          for DrbToBeSetupModList
14345  *
14346  * @details
14347  *
14348  *    Function : freeAperDecodeDrbToBeSetupModList
14349  *
14350  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
14351  *
14352  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
14353  *
14354  * @return void
14355  *
14356  * ****************************************************************/
14357
14358 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
14359 {
14360    uint8_t arrIdx =0;
14361    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
14362
14363    if(drbSet->list.array)
14364    {
14365       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
14366       {
14367          if(drbSet->list.array[arrIdx] != NULLP)
14368          {
14369             if(arrIdx == 0)
14370             {
14371                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
14372                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
14373             }
14374             free(drbSet->list.array[arrIdx]);
14375          }
14376       }
14377       free(drbSet->list.array);
14378    }
14379
14380 }
14381 /*******************************************************************
14382  *
14383  * @brief Deallocating the memory allocated by the aper decoder
14384  *          for UeContextModificationReqMsg
14385  *
14386  * @details
14387  *
14388  *    Function : freeAperDecodeUeContextModificationReqMsg
14389  *
14390  *    Functionality:  Deallocating memory allocated for
14391  *                  UeContextModificationReqMsg
14392  *
14393  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
14394  *
14395  * @return void
14396  *
14397  * ****************************************************************/
14398 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
14399 {
14400    uint8_t arrIdx, ieId;
14401
14402    if(UeContextModifyReq->protocolIEs.list.array)
14403    {
14404       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
14405       {
14406          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
14407          {
14408             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
14409             switch(ieId)
14410             {
14411                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14412                   break;
14413                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14414                   break;
14415                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
14416                   {
14417                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
14418                            value.choice.DRBs_ToBeSetupMod_List);
14419                      break;
14420                   }
14421             }
14422             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
14423          }
14424       }
14425       free(UeContextModifyReq->protocolIEs.list.array);
14426    }
14427 }
14428 /*******************************************************************
14429  *
14430  * @brief processing the F1 UeContextModificationReq
14431  *
14432  * @details
14433  *
14434  *    Function : procF1UeContextModificationReq
14435  *
14436  *    Functionality:  processing the F1 UeContextModificationReq
14437  *
14438  * @params[in] F1AP_PDU_t *f1apMsg
14439  *
14440  * @return
14441  * ****************************************************************/
14442 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
14443 {
14444    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
14445    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
14446    DuUeCb   *duUeCb = NULLP;
14447    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
14448    DRBs_ToBeModified_List_t *drbModifiedCfg;
14449    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
14450
14451    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
14452    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
14453    {
14454       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
14455       {
14456          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14457             {
14458                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
14459                break;
14460             }
14461          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14462             {
14463                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
14464                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
14465                {
14466                   if(duCb.actvCellLst[cellIdx])
14467                   {
14468                      for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
14469                      {
14470                         if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
14471                               (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
14472                         {
14473                            duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
14474                            if(duUeCb->f1UeDb == NULLP)
14475                            {
14476                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
14477                               duUeCb->f1UeDb->cellIdx = cellIdx;
14478                            }
14479                            break;
14480                         }
14481                      }
14482                   }
14483                }
14484                if(duUeCb == NULLP)
14485                {
14486                   DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
14487                   ret = RFAILED;
14488                }
14489                break;
14490             }
14491          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
14492          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
14493             {
14494                if(duUeCb->f1UeDb)
14495                {
14496                   duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
14497                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
14498                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
14499                   {
14500                      drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
14501                                       choice.DRBs_ToBeSetupMod_List;
14502
14503                      if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
14504                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
14505                      {
14506                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
14507                         ret = RFAILED;
14508                      }
14509                   }
14510
14511                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
14512                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
14513
14514                   {
14515                      drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
14516                                       choice.DRBs_ToBeModified_List;
14517                      if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
14518                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
14519                      {
14520                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
14521                         ret = RFAILED;
14522                      }
14523                   }
14524                }
14525                break;
14526             }
14527
14528          case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
14529             {
14530                DU_LOG("\nINFO  -->  DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
14531                if(duUeCb->f1UeDb)
14532                {
14533                   duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
14534                }
14535                break;
14536             }
14537
14538          case ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator:
14539             {
14540                if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator == \
14541                   RRCReconfigurationCompleteIndicator_true)
14542                {
14543                   duUeCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE;
14544                }
14545                break;
14546             }
14547       }
14548    }
14549
14550    if(ret != RFAILED)
14551    {
14552       ret = duProcUeContextModReq(duUeCb);
14553    }
14554    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
14555    return ret;
14556 }
14557
14558 /*****************************************************************i
14559 *
14560 * @brief Free memory allocated for UE Context Release Request
14561 *
14562 * @details
14563 *
14564 *    Function : FreeUeContextReleaseReq
14565 *
14566 *    Functionality:
14567 *         - Free memory allocated for UE Context Release Request
14568 *
14569 * @params[in] F1AP_PDU_t *f1apMsg
14570 * @return void
14571 *
14572 * *************************************************************/
14573 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
14574 {
14575    uint8_t ieIdx;
14576    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
14577
14578    if(f1apMsg)
14579    {
14580       if(f1apMsg->choice.initiatingMessage)
14581       {
14582          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
14583          if(ueReleaseReq->protocolIEs.list.array)
14584          {
14585             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
14586             {
14587                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
14588             }
14589             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
14590          }
14591          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14592       }
14593       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14594    }
14595
14596 }
14597 /*****************************************************************i
14598 *
14599 * @brief Build and Send UE Context Release Request
14600 *
14601 * @details
14602 *
14603 *    Function : BuildAndSendUeContextReleaseReq
14604 *
14605 *    Functionality:
14606 *         - Build and Send UE Context Release Request
14607 *
14608 * @params[in]
14609 * @return ROK     - success
14610 *         RFAILED - failure
14611 *
14612 * *************************************************************/
14613 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
14614 {
14615    bool memAllocFail = false;
14616    uint8_t ieIdx =0;
14617    uint8_t ret = RFAILED;
14618    uint16_t cellIdx =0;
14619    uint16_t crnti = 0;
14620    uint8_t  elementCnt = 0;
14621    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
14622    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
14623    asn_enc_rval_t encRetVal;
14624    F1AP_PDU_t *f1apMsg = NULLP;
14625    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
14626
14627    DU_LOG("\nINFO  --> Building the UE Context Release Request");
14628    do
14629    {
14630       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14631       if(f1apMsg == NULLP)
14632       {
14633          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
14634          break;
14635       }
14636
14637       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14638       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14639       if(f1apMsg->choice.initiatingMessage == NULLP)
14640       {
14641          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
14642          initiatingMessage");
14643          break;
14644       }
14645       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
14646       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
14647       f1apMsg->choice.initiatingMessage->value.present = \
14648       InitiatingMessage__value_PR_UEContextReleaseRequest;
14649
14650       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
14651
14652       elementCnt = 2;
14653
14654       ueReleaseReq->protocolIEs.list.count = elementCnt;
14655       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
14656
14657       /* Initialize the F1Setup members */
14658       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
14659       if(ueReleaseReq->protocolIEs.list.array == NULLP)
14660       {
14661          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
14662          break;
14663       }
14664       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
14665       {
14666          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
14667                sizeof(UEContextReleaseRequest_t));
14668          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
14669          {
14670             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
14671             memAllocFail = true;
14672             break;
14673          }
14674       }
14675       if(memAllocFail == true)
14676          break;
14677
14678       /* Fetching Ue Cb Info*/
14679       GET_CELL_IDX(cellId, cellIdx);
14680       if(duCb.actvCellLst[cellIdx] == NULLP)
14681       {
14682          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
14683          break;
14684       }
14685       else
14686       {
14687          GET_CRNTI(crnti, ueId);
14688          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
14689          {
14690             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
14691             break;
14692          }
14693          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
14694          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
14695       }
14696
14697       ieIdx=0;
14698       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14699       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
14700       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
14701       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
14702       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
14703
14704       ieIdx++;
14705       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14706       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
14707       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
14708       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
14709       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
14710
14711       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14712
14713       /* Encode the F1SetupRequest type as APER */
14714       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14715       encBufSize = 0;
14716       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
14717       /* Encode results */
14718       if(encRetVal.encoded == ENCODE_FAIL)
14719       {
14720          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
14721                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14722          break;
14723       }
14724       else
14725       {
14726          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
14727          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
14728          {
14729             printf("%x",encBuf[ieIdx]);
14730          }
14731       }
14732
14733       /* Sending msg */
14734       if(sendF1APMsg() != ROK)
14735       {
14736          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
14737          break;
14738       }
14739       ret = ROK;
14740       break;
14741    }while(true);
14742
14743    FreeUeContextReleaseReq(f1apMsg);
14744    return ret;
14745 }
14746 /*****************************************************************i
14747  *
14748  * @brief Free memory allocated for UE Context Release Complete
14749  *
14750  * @details
14751  *
14752  *    Function : FreeUeContextReleaseComplete
14753  *
14754  *    Functionality:
14755  *         - Free memory allocated for UE Context Release Complete
14756  *
14757  * @params[in] F1AP_PDU_t *f1apMsg
14758  * @return void
14759  *
14760  * *************************************************************/
14761 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
14762 {
14763    uint8_t ieIdx;
14764    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
14765
14766    if(f1apMsg)
14767    {
14768       if(f1apMsg->choice.successfulOutcome)
14769       {
14770          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
14771          if(ueReleaseComplete->protocolIEs.list.array)
14772          {
14773             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
14774             {
14775                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
14776             }
14777             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
14778          }
14779          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14780       }
14781       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14782    }
14783
14784 }
14785 /*****************************************************************i
14786  *
14787  * @brief Build and Send UE Context Release Complete
14788  *
14789  * @details
14790  *
14791  *    Function : BuildAndSendUeContextReleaseComplete
14792  *
14793  *    Functionality:
14794  *         - Build and Send UE Context Release Complete
14795  *
14796  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
14797  * @return ROK     - success
14798  *         RFAILED - failure
14799  *
14800  * *************************************************************/
14801 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
14802 {
14803    bool memAllocFail = false;
14804    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
14805    asn_enc_rval_t encRetVal;
14806    F1AP_PDU_t *f1apMsg = NULLP;
14807    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
14808
14809    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
14810    do
14811    {
14812       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14813       if(f1apMsg == NULLP)
14814       {
14815          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
14816          break;
14817       }
14818
14819       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
14820       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14821       if(f1apMsg->choice.successfulOutcome == NULLP)
14822       {
14823          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
14824                successfulOutcome");
14825          break;
14826       }
14827       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
14828       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
14829       f1apMsg->choice.successfulOutcome->value.present = \
14830       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
14831
14832       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
14833
14834       elementCnt = 2;
14835       ueReleaseComplete->protocolIEs.list.count = elementCnt;
14836       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
14837
14838       /* Initialize the UE Release Complete members */
14839       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
14840       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
14841       {
14842          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
14843          break;
14844       }
14845       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
14846       {
14847          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
14848                sizeof(UEContextReleaseComplete_t));
14849          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
14850          {
14851             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
14852             elements");
14853             memAllocFail = true;
14854             break;
14855          }
14856       }
14857       if(memAllocFail == true)
14858          break;
14859
14860
14861       ieIdx=0;
14862       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14863       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
14864       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
14865       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
14866       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
14867
14868       ieIdx++;
14869       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14870       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
14871       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
14872       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
14873       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
14874
14875       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14876
14877       /* Encode the F1SetupComplete type as APER */
14878       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14879       encBufSize = 0;
14880       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
14881       /* Encode results */
14882       if(encRetVal.encoded == ENCODE_FAIL)
14883       {
14884          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
14885                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14886          break;
14887       }
14888       else
14889       {
14890          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
14891          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
14892          {
14893             printf("%x",encBuf[ieIdx]);
14894          }
14895       }
14896
14897       /* Sending msg */
14898       if(sendF1APMsg() != ROK)
14899       {
14900          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
14901          break;
14902       }
14903       ret = ROK;
14904       break;
14905    }while(true);
14906
14907    if(ret == ROK && duCb.actvCellLst[cellId-1] && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
14908    {
14909       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
14910       ret = duSendCellDeletReq(cellId);
14911       if(ret != ROK)
14912       {
14913          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
14914                Delete req for CellId");
14915       }
14916    }
14917    FreeUeContextReleaseComplete(f1apMsg);
14918    return ret;
14919
14920 }
14921
14922 /*******************************************************************
14923 *
14924 * @brief added free part for the memory allocated by aper_decoder
14925 *
14926 * @details
14927 *
14928 *    Function : freeAperDecodeUeContextReleaseCommand
14929 *
14930 *    Functionality: added free part for the memory allocated by aper_decoder
14931 *
14932 * @params[in] F1AP_PDU_t *f1apMsg
14933 * @return void
14934 *
14935 * ****************************************************************/
14936 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
14937 {
14938    uint8_t ieIdx=0;
14939    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
14940
14941    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
14942
14943    if(ueContextReleaseCommand->protocolIEs.list.array)
14944    {
14945       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
14946       {
14947          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
14948          {
14949             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
14950             {
14951                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14952                   break;
14953                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14954                   break;
14955                case ProtocolIE_ID_id_Cause:
14956                   break;
14957                case ProtocolIE_ID_id_RRCContainer:
14958                {
14959                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
14960                   {
14961                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
14962                   }
14963                   break;
14964                }
14965                default :
14966                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
14967                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
14968                   break;
14969             }
14970          }
14971          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
14972       }
14973       free(ueContextReleaseCommand->protocolIEs.list.array);
14974    }
14975 }
14976 /*******************************************************************
14977 *
14978 * @brief processing of UE Context Release Command
14979 *
14980 * @details
14981 *
14982 *    Function : procF1UeContextReleaseCommand
14983 *
14984 *    Functionality: processing of UE Context Release Command
14985 *
14986 * @params[in] F1AP_PDU_t *f1apMsg
14987 * @return void
14988 *
14989 * ****************************************************************/
14990 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
14991 {
14992    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
14993    uint16_t cellIdx =0, cellId = 0;
14994    bool ueIdxFound = false;
14995    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
14996    DuUeCb   *duUeCb = NULLP;
14997    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
14998
14999    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
15000
15001    if(ueContextReleaseCommand->protocolIEs.list.array)
15002    {
15003       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
15004       {
15005          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
15006          {
15007             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
15008             {
15009                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15010                   {
15011                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
15012                                     value.choice.GNB_CU_UE_F1AP_ID;
15013                      break;
15014                   }
15015
15016                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15017                   {
15018                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
15019                                      value.choice.GNB_DU_UE_F1AP_ID;
15020                      break;
15021                   }
15022
15023                case ProtocolIE_ID_id_Cause:
15024                   {
15025                      for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
15026                      {
15027                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
15028                         {
15029                            if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
15030                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
15031                            {
15032                               cellId = duCb.actvCellLst[cellIdx]->cellId;
15033                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
15034                               ueIdxFound = true;
15035                               break;
15036                            }
15037                         }
15038                         if(ueIdxFound == true)
15039                         {
15040                            break;
15041                         }
15042                      }
15043
15044                      if(!ueIdxFound)
15045                      {
15046                         DU_LOG("\nERROR  -->  F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
15047                         ret = RFAILED;
15048                      }
15049                      break;
15050                   }
15051
15052                case ProtocolIE_ID_id_RRCContainer:
15053                   {
15054                      if(ueIdxFound == true)
15055                      {
15056                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
15057                         if(duUeCb->f1UeDb)
15058                         {
15059                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
15060                            duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
15061                            duUeCb->f1UeDb->cellIdx = cellIdx;
15062                            /* Filling Dl RRC Msg Info */
15063                            DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
15064                            if(!duUeCb->f1UeDb->dlRrcMsg)
15065                            {
15066                               DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
15067                                     Memory allocation failed ");
15068                               ret = RFAILED;
15069                            }
15070                            else
15071                            {
15072                               duUeCb->f1UeDb->dlRrcMsgPres = true;
15073                               memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
15074                               ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
15075                                     &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
15076                                     value.choice.RRCContainer);
15077                            }
15078
15079                         }
15080                         else
15081                         {
15082                            DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
15083                                  Memory allocation failed ");
15084                            ret = RFAILED;
15085
15086                         }
15087                      }
15088                      break;
15089                   }
15090                default :
15091                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
15092                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
15093                   break;
15094             }
15095          }
15096       }
15097    }
15098    if(ret != RFAILED)
15099    {
15100       duProcUeContextReleaseCommand(cellId, duUeCb);
15101    }
15102    freeAperDecodeUeContextReleaseCommand(f1apMsg);
15103    return ret;
15104 }
15105 /**************************************************************
15106  *
15107  * @brief Handles received F1AP message and sends back response
15108  *
15109  * @details
15110  *
15111  *    Function : F1APMsgHdlr
15112  *
15113  *    Functionality:
15114  *         - Decodes received F1AP control message
15115  *         - Prepares response message, encodes and sends to SCTP
15116  *
15117  * @params[in]
15118  * @return ROK     - success
15119  *         RFAILED - failure
15120  *
15121  * ****************************************************************/
15122 void F1APMsgHdlr(Buffer *mBuf)
15123 {
15124    int i =0;
15125    char *recvBuf =NULLP;
15126    MsgLen copyCnt =0;
15127    MsgLen recvBufLen =0;
15128    F1AP_PDU_t *f1apMsg =NULLP;
15129    asn_dec_rval_t rval; /* Decoder return value */
15130    F1AP_PDU_t f1apasnmsg ;
15131    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
15132    ODU_PRINT_MSG(mBuf, 0,0);
15133
15134    /* Copy mBuf into char array to decode it */
15135    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
15136    DU_ALLOC(recvBuf, (Size)recvBufLen);
15137
15138    if(recvBuf == NULLP)
15139    {
15140       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
15141       return;
15142    }
15143    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
15144    {
15145       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
15146       return;
15147    }
15148
15149    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
15150    for(i=0; i< recvBufLen; i++)
15151    {
15152       printf("%x",recvBuf[i]);
15153    }
15154
15155    /* Decoding flat buffer into F1AP messsage */
15156    f1apMsg = &f1apasnmsg;
15157    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
15158
15159    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
15160
15161    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
15162    {
15163       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
15164       return;
15165    }
15166    printf("\n");
15167    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15168
15169    switch(f1apMsg->present)
15170    {
15171       case F1AP_PDU_PR_successfulOutcome:
15172          {
15173             switch(f1apMsg->choice.successfulOutcome->value.present)
15174             {
15175                case SuccessfulOutcome__value_PR_ResetAcknowledge:
15176                   {
15177                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
15178                      break;
15179                   }
15180                case SuccessfulOutcome__value_PR_F1SetupResponse:
15181                   {
15182 #ifndef ODU_TEST_STUB
15183                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
15184 #endif
15185                      break;
15186                   }
15187
15188                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
15189                   {
15190                      procF1GNBDUCfgUpdAck(f1apMsg);
15191                      break;
15192                   }
15193
15194                default:
15195                   {
15196                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
15197                            f1apMsg->choice.successfulOutcome->value.present);
15198                      return;
15199                   }
15200             }/* End of switch(successfulOutcome) */
15201             free(f1apMsg->choice.successfulOutcome);
15202             break;
15203          }
15204       case F1AP_PDU_PR_initiatingMessage:
15205          {
15206             switch(f1apMsg->choice.initiatingMessage->value.present)
15207             {
15208                case InitiatingMessage__value_PR_Reset:
15209                   {
15210                      procF1ResetReq(f1apMsg);
15211                      break;
15212                   }
15213                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
15214                   {
15215                      procF1DlRrcMsgTrans(f1apMsg);
15216                      break;
15217                   }
15218                case InitiatingMessage__value_PR_UEContextSetupRequest:
15219                   {
15220                      procF1UeContextSetupReq(f1apMsg);
15221                      break;
15222                   }
15223                case InitiatingMessage__value_PR_UEContextModificationRequest:
15224                   {
15225                      procF1UeContextModificationReq(f1apMsg);
15226                      break;
15227                   }
15228                case InitiatingMessage__value_PR_UEContextReleaseCommand:
15229                   {
15230                       procF1UeContextReleaseCommand(f1apMsg);
15231                       break;
15232                   }
15233                default:
15234                   {
15235                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
15236                            f1apMsg->choice.initiatingMessage->value.present);
15237                      return;
15238                   }
15239             }/* End of switch(initiatingMessage) */
15240             free(f1apMsg->choice.initiatingMessage);
15241             break;
15242          }
15243
15244       default:
15245          {
15246             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
15247             return;
15248          }
15249          free(f1apMsg);
15250
15251    }/* End of switch(f1apMsg->present) */
15252
15253    DU_FREE(recvBuf, (Size)recvBufLen);
15254 } /* End of F1APMsgHdlr */
15255
15256 /**********************************************************************
15257   End of file
15258  **********************************************************************/