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 "ckw.h"
  22 #include "ckw.x"
  23 #include "kwu.h"
  24 #include "kwu.x"
  25 #include "lkw.h"
  26 #include "lrg.h"
  27 #include "legtp.h"
  28 #include "lkw.x"
  29 #include "lrg.x"
  30 #include "F1AP-PDU.h"
  31 #include "du_app_mac_inf.h"
  32 #include "du_cfg.h"
  33 #include "du_app_rlc_inf.h"
  34 #include "du_mgr_main.h"
  35 #include "du_mgr.h"
  36 #include "du_utils.h"
  37 #include "du_ue_mgr.h"
  38 #include "RAT-Type.h"
  39 #include "FeatureSetUplinkPerCC.h"
  40 #include "FeatureSetDownlinkPerCC.h"
  41 #include "FeatureSets.h"
  42 #include "UE-NR-Capability.h"
  43 #include "UE-CapabilityRAT-Container.h"
  44 #include "UE-CapabilityRAT-ContainerListRRC.h"
  45 #include "GNB-DU-System-Information.h"
  46 #include "CellGroupConfigRrc.h"
  47 #include "MAC-CellGroupConfig.h"
  48 #include "SchedulingRequestConfig.h"
  49 #include "SchedulingRequestToAddMod.h"
  50 #include "BSR-Config.h"
  51 #include "TAG-Config.h"
  52 #include "TAG.h"
  53 #include "PHR-Config.h"
  54 #include "RLC-Config.h"
  55 #include "UL-AM-RLC.h"
  56 #include "DL-AM-RLC.h"
  57 #include "LogicalChannelConfig.h"
  58 #include "RLC-BearerConfig.h"
  59 #include "PhysicalCellGroupConfig.h"
  60 #include "SpCellConfig.h"
  61 #include "TDD-UL-DL-ConfigDedicated.h"
  62 #include "ServingCellConfig.h"
  63 #include "ControlResourceSet.h"
  64 #include "SearchSpace.h"
  65 #include "PDCCH-Config.h"
  66 #include "PDSCH-TimeDomainResourceAllocation.h"
  67 #include "PDSCH-TimeDomainResourceAllocationList.h"
  68 #include "PDSCH-CodeBlockGroupTransmission.h"
  69 #include "PDSCH-ServingCellConfig.h"
  70 #include "DMRS-DownlinkConfig.h"
  71 #include "PDSCH-Config.h"
  72 #include "BWP-DownlinkDedicated.h"
  73 #include "BWP-Downlink.h"
  74 #include "PUSCH-TimeDomainResourceAllocation.h"
  75 #include "PUSCH-TimeDomainResourceAllocationList.h"
  76 #include "DMRS-UplinkConfig.h"
  77 #include "PUSCH-Config.h"
  78 #include "SRS-ResourceId.h"
  79 #include "SRS-Resource.h"
  80 #include "SRS-ResourceSet.h"
  81 #include "SRS-Config.h"
  82 #include "BWP-UplinkDedicated.h"
  83 #include "PUSCH-ServingCellConfig.h"
  84 #include "UplinkConfig.h"
  85 #include "DUtoCURRCContainer.h"
  86 #include "GBR-QoSFlowInformation.h"
  87 #include "QoSFlowLevelQoSParameters.h"
  88 #include "PUCCH-Config.h"
  89 #include "PUCCH-ResourceSet.h"
  90 #include "PUCCH-Resource.h"
  91 #include "PUCCH-PowerControl.h"
  92 #include "P0-PUCCH.h"
  93 #include "PUCCH-PathlossReferenceRS.h"
  94 #include "PUCCH-format0.h"
  95 #include "PUCCH-format1.h"
  96 #include "PUCCH-format2.h"
  97 #include "PUCCH-format3.h"
  98 #include "PUCCH-format4.h"
  99 #include "PUCCH-FormatConfig.h"
 100 #include "SchedulingRequestResourceConfig.h"
 101 #include<ProtocolIE-Field.h>
 102 #include "ProtocolExtensionField.h"
 103 #include "odu_common_codec.h"
 104 #include "du_mgr.h"
 105 #include "du_cell_mgr.h"
 106 #include "du_f1ap_msg_hdl.h"
 107 #include "DRBs-Setup-Item.h"
 108 #include "DLUPTNLInformation-ToBeSetup-List.h"
 109 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 110 #include "UPTransportLayerInformation.h"
 111 #include "GTPTunnel.h"
 112 #include "SupportedSULFreqBandItem.h"
 113 #include "du_sys_info_hdl.h"
 114 #include "du_e2ap_msg_hdl.h"
 115 #include "du_f1ap_conversions.h"
 116 #include "CNUEPagingIdentity.h"
 117 #include "PCCH-Config.h"
 118
 119 #ifdef O1_ENABLE
 120 #include "CmInterface.h"
 121 extern StartupConfig g_cfg;
 122 #endif
 123
 124 DuCfgParams duCfgParam;
 125
 126 /******************************************************************
 127  *
 128  * @brief Function to fetch lcId based on DRB Id
 129  *
 130  * @details
 131  *
 132  *    Function : fetchLcId
 133  *
 134  *    @params[in] drbId
 135  *
 136  *    Functionality: Function to fetch lcId based on DRB Id
 137  *
 138  * Returns: lcId - SUCCESS
 139  *          RFAILED - FAILURE
 140  *****************************************************************/
 141
 142 uint8_t fetchLcId(uint8_t drbId)
 143 {
 144    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 145
 146    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 147    {
 148       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 149       {
 150          if(duCb.actvCellLst[cellIdx] != NULLP)
 151          {
 152             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.numLcs;
 153             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 154             {
 155                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbId == drbId && \
 156                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbType == RB_TYPE_DRB)
 157                {
 158                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].lcId;
 159                   return lcId;
 160                }
 161             }
 162          }
 163       }
 164    }
 165    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 166    return RFAILED;
 167 }
 168
 169 /*******************************************************************
 170 *
 171 * @brief Adding F1AP pdu to reserved pdu list
 172 *
 173 * @details
 174 *
 175 *    Function : addToReservedF1apPduList
 176 *
 177 *    Functionality: Adding F1AP pdu to reserved pdu list.
 178 *     These pdu are awaiting aknowledgment from CU
 179 *
 180 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 181 *
 182 * @return ROK - success
 183 *         RFAILED - failure
 184 *
 185 * ****************************************************************/
 186 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 187 {
 188    CmLList         *node = NULLP;
 189    ReservedF1apPduInfo *pduInfo = NULLP;
 190    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 191    if(pduInfo)
 192    {
 193       DU_ALLOC(node, sizeof(CmLList));
 194       if(node)
 195       {
 196          pduInfo->transId = transId;
 197          pduInfo->f1apMsg = (void*) f1apPdu;
 198
 199          node->node = (PTR)pduInfo;
 200          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 201       }
 202    }
 203 }
 204
 205 /*******************************************************************
 206 *
 207 * @brief searching for F1AP pdu from ReservedF1apPduList
 208 *
 209 * @details
 210 *
 211 *    Function : searchFromReservedF1apPduList
 212 *
 213 *    Functionality: searching for F1AP pdu information
 214 *
 215 * @params[in] uint8_t transId
 216 *
 217 * @return pointer to F1AP_PDU_t
 218 *
 219 * ****************************************************************/
 220
 221 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 222 {
 223    CmLList         *node;
 224    ReservedF1apPduInfo *f1apPdu;
 225    if(duCb.reservedF1apPduList.count)
 226    {
 227       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 228       while(node)
 229       {
 230          f1apPdu = (ReservedF1apPduInfo*)node->node;
 231          if(f1apPdu->transId == transId)
 232          {
 233             return node;
 234          }
 235          node = node->next;
 236       }
 237    }
 238    return NULL;
 239 }
 240
 241 /*******************************************************************
 242 *
 243 * @brief deleting F1AP pdu information from ReservedF1apPduList
 244 *
 245 * @details
 246 *
 247 *    Function : deleteFromReservedF1apPduList
 248 *
 249 *    Functionality: deleting pdu information from ReservedF1apPduList
 250 *
 251 * @params[in] CmLList *node
 252 *
 253 * @return void
 254 *
 255 * ****************************************************************/
 256
 257 void deleteFromReservedF1apPduList(CmLList *node)
 258 {
 259    ReservedF1apPduInfo *f1apPdu;
 260
 261    if(node != NULL)
 262    {
 263       f1apPdu = (ReservedF1apPduInfo *)node->node;
 264       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 265       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 266       DU_FREE(node, sizeof(CmLList));
 267       node = NULL;
 268    }
 269 }
 270
 271 /*******************************************************************
 272  *
 273  * @brief Builds Uplink Info for NR
 274  *
 275  * @details
 276  *
 277  *    Function : BuildULNRInfo
 278  *
 279  *    Functionality: Building NR Uplink Info
 280  *
 281  * @params[in] NRFreqInfo_t *ulnrfreq
 282  * @return ROK     - success
 283  *         RFAILED - failure
 284  *
 285  * ****************************************************************/
 286 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 287 {
 288    uint8_t idx=0;
 289    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 290                        fdd.ulNrFreqInfo.nrArfcn;
 291    ulnrfreq->freqBandListNr.list.count = 1;
 292    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 293    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 294    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 295    {
 296       return RFAILED;
 297    }
 298    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 299    {
 300       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 301       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 302       {
 303          return RFAILED;
 304       }
 305    }
 306    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 307                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 308                                                                  freqBand[0].nrFreqBand;
 309    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 310    return ROK;
 311 }
 312 /*******************************************************************
 313  *
 314  * @brief Builds Downlink NR Info
 315  *
 316  * @details
 317  *
 318  *    Function : BuildDLNRInfo
 319  *
 320  *    Functionality: Building Downlink NR Info
 321  *
 322  * @params[in] NRFreqInfo_t *dlnrfreq
 323  * @return ROK     - success
 324  *         RFAILED - failure
 325  *
 326  * ****************************************************************/
 327 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 328 {
 329    uint8_t idx=0;
 330    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 331                        fdd.dlNrFreqInfo.nrArfcn;
 332    dlnrfreq->freqBandListNr.list.count = 1;
 333    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 334    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 335    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 336    {
 337       return RFAILED;
 338    }
 339    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 340    {
 341       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 342       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 343       {
 344          return RFAILED;
 345       }
 346    }
 347    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 348                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 349                                                                  freqBand[0].nrFreqBand;
 350    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 351
 352    return ROK;
 353 }
 354
 355 /*******************************************************************
 356  *
 357  * @brief Builds NRCell ID
 358  *
 359  * @details
 360  *
 361  *    Function : BuildNrCellId
 362  *
 363  *    Functionality: Building the NR Cell ID
 364  *
 365  * @params[in] BIT_STRING_t *nrcell
 366  * @return ROK     - success
 367  *         RFAILED - failure
 368  *
 369  * ****************************************************************/
 370
 371 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 372 {
 373    memset(nrcell->buf, 0, nrcell->size);
 374    nrcell->buf[4]   = duCfgParam.sib1Params.cellIdentity;
 375    nrcell->bits_unused = 4;
 376    return ROK;
 377 }
 378
 379 /*******************************************************************
 380  *
 381  * @brief Builds Nrcgi
 382  *
 383  * @details
 384  *
 385  *    Function : BuildNrcgi
 386  *
 387  *    Functionality: Building the PLMN ID and NR Cell id
 388  *
 389  * @params[in] NRCGI_t *nrcgi
 390  * @return ROK     - success
 391  *         RFAILED - failure
 392  *
 393  * ****************************************************************/
 394 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 395 {
 396    uint8_t ret;
 397    uint8_t byteSize = 5;
 398    /* Allocate Buffer Memory */
 399    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 400    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 401    if(nrcgi->pLMN_Identity.buf == NULLP)
 402    {
 403       return RFAILED;
 404    }
 405    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 406          nrcgi->pLMN_Identity.buf); // Building PLMN function
 407    if(ret != ROK)
 408    {
 409       return RFAILED;
 410    }
 411    /*nrCellIdentity*/
 412    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 413    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 414    if(nrcgi->nRCellIdentity.buf == NULLP)
 415    {
 416       return RFAILED;
 417    }
 418    BuildNrCellId(&nrcgi->nRCellIdentity);
 419
 420    return ROK;
 421 }
 422 /*******************************************************************
 423  *
 424  * @brief Builds FiveGStac
 425  *
 426  * @details
 427  *
 428  *    Function : BuildFiveGSTac
 429  *
 430  *    Functionality: Building the FiveGSTac
 431  *
 432  * @params[in] OCTET_STRING_t *fivegsTac
 433  * @return ROK     - success
 434  *         RFAILED - failure
 435  *
 436  * ****************************************************************/
 437 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 438 {
 439    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 440    if(servcell->fiveGS_TAC == NULLP)
 441    {
 442       return RFAILED;
 443    }
 444    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 445    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 446          sizeof(servcell->fiveGS_TAC->size));
 447    if(servcell->fiveGS_TAC->buf == NULLP)
 448    {
 449       return RFAILED;
 450    }
 451    servcell->fiveGS_TAC->buf[0] = 0;
 452    servcell->fiveGS_TAC->buf[1] = 0;
 453    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 454    return ROK;
 455 }
 456
 457 /*******************************************************************
 458  *
 459  * @brief fill nr frequency information
 460  *
 461  * @details
 462  *
 463  *    Function : fillNrTddInfo
 464  *
 465  *    Functionality: fill nr frequency information
 466  *
 467  * @params[in] NRFreqInfo_t freqInfo
 468  * @return ROK     - success
 469  *         RFAILED - failure
 470  *
 471  * ****************************************************************/
 472 uint8_t fillNrTddInfo(TDD_Info_t *tddInfo)
 473 {
 474    uint8_t elementCnt = 1, freqBandListIdx = 0, supportedBandIdx = 0;
 475    NRFreqInfo_t *freqInfo = NULLP;
 476
 477    if(tddInfo == NULLP)
 478    {
 479       DU_LOG("\nERROR  --> DU APP : Null pointer received at fillNrTddInfo");
 480       return RFAILED;
 481    }
 482
 483    freqInfo = &tddInfo->nRFreqInfo;
 484    freqInfo->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn;
 485
 486    freqInfo->freqBandListNr.list.count = elementCnt;
 487    freqInfo->freqBandListNr.list.size = freqInfo->freqBandListNr.list.count  * sizeof(FreqBandNrItem_t *);
 488    DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
 489    if(!freqInfo->freqBandListNr.list.array)
 490    {
 491       DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 492       return RFAILED;
 493    }
 494
 495    for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
 496    {
 497       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
 498       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
 499       {
 500          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 501          return RFAILED;
 502       }
 503
 504       freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
 505       f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
 506       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
 507       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
 508       supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
 509
 510       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
 511             freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
 512       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
 513       {
 514          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 515          return RFAILED;
 516       }
 517
 518       for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
 519       {
 520          DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
 521                sizeof(SupportedSULFreqBandItem_t));
 522          if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
 523          {
 524             DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 525             return RFAILED;
 526          }
 527
 528          freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx]->freqBandIndicatorNr =\
 529          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.freqBand[0].sulBand[0];
 530       }
 531    }
 532
 533    tddInfo->transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs;
 534    tddInfo->transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb;
 535
 536    return ROK;
 537 }
 538
 539 /*******************************************************************
 540  *
 541  * @brief Builds NR Mode
 542  *
 543  * @details
 544  *
 545  *    Function : BuildNrMode
 546  *
 547  *    Functionality: Building the NR Mode
 548  *
 549  * @params[in] NR_Mode_Info_t *fdd
 550  * @return ROK     - success
 551  *         RFAILED - failure
 552  *
 553  * ****************************************************************/
 554 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 555 {
 556    uint8_t BuildDLNRInforet=0;
 557    uint8_t BuildULNRInforet=0;
 558
 559 #ifdef NR_TDD
 560    mode->present = NR_Mode_Info_PR_tDD;
 561 #else
 562    mode->present = NR_Mode_Info_PR_fDD;
 563 #endif
 564
 565    if(mode->present == NR_Mode_Info_PR_fDD)
 566    {
 567       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 568       if(mode->choice.fDD == NULLP)
 569       {
 570          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 571          return RFAILED;
 572       }
 573       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 574       if(BuildULNRInforet != ROK)
 575       {
 576          DU_LOG("\nERROR  --> Failed to build UlNrFreqInfo");
 577          return RFAILED;
 578       }
 579       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 580       if(BuildDLNRInforet != ROK)
 581       {
 582          DU_LOG("\nERROR  --> Failed to build DlNrFreqInfo");
 583          return RFAILED;
 584       }
 585       mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 586                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 587                                                           f1Mode.mode.fdd.ulTxBw.nrScs;
 588       mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 589                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 590                                                           f1Mode.mode.fdd.ulTxBw.nrb;
 591       mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 592                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 593                                                           f1Mode.mode.fdd.dlTxBw.nrScs;
 594       mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 595                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 596                                                           f1Mode.mode.fdd.dlTxBw.nrb;
 597    }
 598    else if(mode->present == NR_Mode_Info_PR_tDD)
 599    {
 600       DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
 601       if(mode->choice.tDD == NULLP)
 602       {
 603          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 604          return RFAILED;
 605       }
 606
 607       if(fillNrTddInfo(mode->choice.tDD) != ROK)
 608       {
 609          DU_LOG("\nERROR  --> Failed to fill Nr TDD information");
 610          return RFAILED;
 611       }
 612
 613    }
 614
 615    return ROK;
 616 }
 617 /*******************************************************************
 618  *
 619  * @brief Builds IE Extensions for Served PLMNs
 620  *
 621  * @details
 622  *
 623  *    Function : BuildExtensions
 624  *
 625  *    Functionality: Building the IE Extensions
 626  *
 627  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 628  * @return ROK     - success
 629  *         RFAILED - failure
 630  *
 631  * ****************************************************************/
 632 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 633 {
 634    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 635    uint8_t elementCnt=0, extensionCnt=0;
 636
 637    extensionCnt=IE_EXTENSION_LIST_COUNT;
 638    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 639    if((*ieExtend) == NULLP)
 640    {
 641       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 642       return RFAILED;
 643    }
 644    (*ieExtend)->list.count = extensionCnt;
 645    (*ieExtend)->list.size = \
 646                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 647    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 648    if((*ieExtend)->list.array == NULLP)
 649    {
 650       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 651       return RFAILED;
 652    }
 653    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 654    {
 655       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 656             sizeof(ServedPLMNs_ItemExtIEs_t));
 657       if((*ieExtend)->list.array[plmnidx] == NULLP)
 658       {
 659          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 660          return RFAILED;
 661       }
 662    }
 663
 664    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 665    idx = 0;
 666    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 667    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 668    (*ieExtend)->list.array[idx]->extensionValue.present = \
 669    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 670    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 671       list.count = elementCnt;
 672    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 673       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 674       list.count * sizeof(SliceSupportItem_t *);
 675
 676    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 677          list.array, elementCnt * sizeof(SliceSupportItem_t *));
 678    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 679          list.array == NULLP)
 680    {
 681       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 682       return RFAILED;
 683    }
 684
 685    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
 686    {
 687       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 688             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
 689       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 690             list.array[sliceLstIdx] == NULLP)
 691       {
 692          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 693          return RFAILED;
 694       }
 695       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 696          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
 697       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 698             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 699             extensionValue.choice.SliceSupportList.\
 700             list.array[sliceLstIdx]->sNSSAI.sST.size);
 701       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 702             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
 703       {
 704          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 705          return RFAILED;
 706       }
 707       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 708          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
 709          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
 710
 711       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 712             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 713       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 714             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
 715       {
 716          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 717          return RFAILED;
 718       }
 719       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 720          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
 721       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 722             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
 723             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 724       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 725             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
 726       {
 727          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 728          return RFAILED;
 729       }
 730       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 731       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
 732       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
 733       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 734    }
 735    return ROK;
 736 }
 737 /*******************************************************************
 738  *
 739  * @brief Builds Served PLMN
 740  *
 741  * @details
 742  *
 743  *    Function : BuildServedPlmn
 744  *
 745  *    Functionality: Building the Served PLMN
 746  *
 747  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 748  * @return ROK     - success
 749  *         RFAILED - failure
 750  *
 751  * ****************************************************************/
 752 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 753 {
 754    uint8_t  plmnidx;
 755    uint8_t  servPlmnCnt=1;
 756    uint8_t buildPlmnIdret=0;
 757    uint8_t BuildExtensionsret=0;
 758    srvplmn->list.count = servPlmnCnt;
 759    srvplmn->list.size = \
 760                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 761    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 762    if(srvplmn->list.array == NULLP)
 763    {
 764       return RFAILED;
 765    }
 766    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 767    {
 768       DU_ALLOC(srvplmn->list.array[plmnidx],\
 769             sizeof(ServedPLMNs_Item_t));
 770       if(srvplmn->list.array[plmnidx] == NULLP)
 771       {
 772          return RFAILED;
 773       }
 774    }
 775    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 776    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 777    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 778          srvplmn->list.array[0]->pLMN_Identity.buf);
 779    if(buildPlmnIdret!= ROK)
 780    {
 781       return RFAILED;
 782    }
 783    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 784    if(BuildExtensionsret!= ROK)
 785    {
 786       return RFAILED;
 787    }
 788    return ROK;
 789 }
 790 /*******************************************************************
 791  *
 792  * @brief Builds Served Cell List
 793  *
 794  * @details
 795  *
 796  *    Function : BuildServedCellList
 797  *
 798  *    Functionality: Building Served Cell List
 799  *
 800  * @params[in] PLMNID plmn
 801  * @return ROK     - success
 802  *         RFAILED - failure
 803  *
 804  * ****************************************************************/
 805
 806 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 807 {
 808    uint8_t  BuildNrcgiret=0;
 809    uint8_t  BuildFiveGSTacret=0;
 810    uint8_t  BuildServedPlmnret=0;
 811    uint8_t  BuildNrModeret=0;
 812    uint8_t  idx;
 813    uint8_t  plmnidx;
 814    uint8_t  plmnCnt=1;
 815    GNB_DU_Served_Cells_Item_t *srvCellItem;
 816    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 817    duServedCell->list.count = plmnCnt;
 818
 819    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
 820    if(duServedCell->list.array == NULLP)
 821    {
 822       return RFAILED;
 823    }
 824    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 825    {
 826       DU_ALLOC(duServedCell->list.array[plmnidx],\
 827             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 828       if(duServedCell->list.array[plmnidx] == NULLP)
 829       {
 830          return RFAILED;
 831       }
 832    }
 833    idx = 0;
 834    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 835    duServedCell->list.array[idx]->criticality = Criticality_reject;
 836    duServedCell->list.array[idx]->value.present = \
 837                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 838    srvCellItem = \
 839                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 840    /*nRCGI*/
 841    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 842    if(BuildNrcgiret != ROK)
 843    {
 844       return RFAILED;
 845    }
 846    /*nRPCI*/
 847    srvCellItem->served_Cell_Information.nRPCI = \
 848                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 849
 850    /*fiveGS_TAC*/
 851    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 852    if(BuildFiveGSTacret != ROK)
 853    {
 854       return RFAILED;
 855    }
 856    /*Served PLMNs*/
 857    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 858    if(BuildServedPlmnret !=ROK)
 859    {
 860       return RFAILED;
 861    }
 862    /*nR Mode Info with FDD*/
 863    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 864    if(BuildNrModeret != ROK)
 865    {
 866       return RFAILED;
 867    }
 868    /*Measurement timing Config*/
 869    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 870       size = sizeof(uint8_t);
 871    DU_ALLOC(srvCellItem->served_Cell_Information.\
 872          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 873    if(srvCellItem->served_Cell_Information.\
 874          measurementTimingConfiguration.buf == NULLP)
 875    {
 876       return RFAILED;
 877    }
 878    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 879                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 880
 881    /* GNB DU System Information */
 882    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 883          sizeof(GNB_DU_System_Information_t));
 884    if(!srvCellItem->gNB_DU_System_Information)
 885    {
 886       return RFAILED;
 887    }
 888    /* MIB */
 889    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
 890    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 891          srvCellItem->gNB_DU_System_Information->mIB_message.size);
 892    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 893    {
 894       return RFAILED;
 895    }
 896    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
 897                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
 898
 899    /* SIB1 */
 900    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 901                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 902
 903    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 904          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 905    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 906    {
 907       return RFAILED;
 908    }
 909    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 910    {
 911       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 912                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 913    }
 914    return ROK;
 915 }
 916 /*******************************************************************
 917  *
 918  * @brief Builds RRC Version
 919  *
 920  * @details
 921  *
 922  *    Function : BuildRrcVer
 923  *
 924  *    Functionality: Building RRC Version
 925  *
 926  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 927  * @return ROK     - success
 928  *         RFAILED - failure
 929  *
 930  * ****************************************************************/
 931 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
 932 {
 933    uint8_t rrcExt;
 934    uint8_t rrcLatest;
 935    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
 936    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
 937    if(rrcVer->latest_RRC_Version.buf == NULLP)
 938    {
 939       return RFAILED;
 940    }
 941    rrcVer->latest_RRC_Version.buf[0] = 0;
 942    rrcVer->latest_RRC_Version.bits_unused = 5;
 943    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 944    if(rrcVer->iE_Extensions == NULLP)
 945    {
 946       return RFAILED;
 947    }
 948    rrcVer->iE_Extensions->list.count = 1;
 949    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
 950    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
 951    if(rrcVer->iE_Extensions->list.array == NULLP)
 952    {
 953       return RFAILED;
 954    }
 955    rrcExt = 0;
 956    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 957          sizeof(RRC_Version_ExtIEs_t));
 958    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 959    {
 960       return RFAILED;
 961    }
 962    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
 963                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 964    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
 965    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
 966                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 967    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 968       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 969    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 970          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 971          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 972    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 973          .Latest_RRC_Version_Enhanced.buf == NULLP)
 974    {
 975       return RFAILED;
 976    }
 977    rrcLatest = 0;
 978    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 979       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
 980    rrcLatest++;
 981    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 982       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
 983    rrcLatest++;
 984    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 985       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
 986    return ROK;
 987 }
 988 /*******************************************************************
 989  *
 990  * @brief Sends F1 msg over SCTP
 991  *
 992  * @details
 993  *
 994  *    Function : sendF1APMsg
 995  *
 996  *    Functionality: Sends F1 msg over SCTP
 997  *
 998  * @params[in] Region region
 999  *             Pool pool
1000  * @return ROK     - success
1001  *         RFAILED - failure
1002  *
1003  * ****************************************************************/
1004 uint8_t sendF1APMsg()
1005 {
1006    Buffer *mBuf = NULLP;
1007
1008    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1009    {
1010       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1011       {
1012             ODU_PRINT_MSG(mBuf, 0,0);
1013
1014             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1015             {
1016                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1017                ODU_PUT_MSG_BUF(mBuf);
1018                return RFAILED;
1019             }
1020       }
1021       else
1022       {
1023          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1024          ODU_PUT_MSG_BUF(mBuf);
1025          return RFAILED;
1026       }
1027       ODU_PUT_MSG_BUF(mBuf);
1028    }
1029    else
1030    {
1031       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1032       return RFAILED;
1033    }
1034    return ROK;
1035 } /* sendF1APMsg */
1036
1037 /*******************************************************************
1038  *
1039  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1040  *
1041  * @details
1042  *
1043  *    Function :  FreeRrcVer
1044  *
1045  *    Functionality: deallocating the memory of function BuildRrcVer
1046  *
1047  * @params[in] RRC_Version_t *rrcVer
1048  *
1049  * @return void
1050  *
1051  *****************************************************************/
1052 void FreeRrcVer(RRC_Version_t *rrcVer)
1053 {
1054    if(rrcVer->latest_RRC_Version.buf != NULLP)
1055    {
1056       if(rrcVer->iE_Extensions != NULLP)
1057       {
1058          if(rrcVer->iE_Extensions->list.array != NULLP)
1059          {
1060             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1061             {
1062                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1063                      != NULLP)
1064                {
1065                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1066                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1067                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1068                }
1069                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1070             }
1071             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1072          }
1073          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1074       }
1075       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1076    }
1077 }
1078
1079 /*******************************************************************
1080  *
1081  * @brief Deallocating memory of TDD NrFreqInfo
1082  *
1083  * @details
1084  *
1085  *    Function : freeTddNrFreqInfo
1086  *
1087  *    Functionality: freeTddNrFreqInfo
1088  *
1089  * @params[in]  F1AP_PDU_t *f1apDuCfg
1090  *
1091  * @return ROK     - void
1092  *
1093  * ****************************************************************/
1094 void freeTddNrFreqInfo(NRFreqInfo_t *freqInfo)
1095 {
1096    uint8_t freqBandListIdx = 0, supportedBandIdx = 0;
1097
1098    if(freqInfo->freqBandListNr.list.array)
1099    {
1100       for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
1101       {
1102          if(freqInfo->freqBandListNr.list.array[freqBandListIdx])
1103          {
1104             if(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
1105             {
1106                for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
1107                {
1108                   DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1109                         sizeof(SupportedSULFreqBandItem_t));
1110                }
1111                DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
1112                      freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
1113
1114             }
1115             DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
1116          }
1117       }
1118       DU_FREE(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
1119    }
1120 }
1121
1122 /*******************************************************************
1123  *
1124  * @brief Deallocating memory allocated for Nr fdd frequencey mode
1125  *
1126  * @details
1127  *
1128  *    Function : freeFddNrFreqInfo
1129  *
1130  *    Functionality:Free memory allocated for Nr fdd frequencey mode
1131  *
1132  * @params[in]
1133  *
1134  * @return ROK     - void
1135  *
1136  * ****************************************************************/
1137 void freeFddNrFreqInfo(FDD_Info_t *fDD)
1138 {
1139    uint8_t arrIdx =0;
1140
1141    if(fDD != NULLP)
1142    {
1143       if(fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1144       {
1145          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1146                array[arrIdx], sizeof(FreqBandNrItem_t));
1147          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1148                fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1149       }
1150
1151       if(fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1152       {
1153          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.\
1154                array[arrIdx], sizeof(FreqBandNrItem_t));
1155          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1156                fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1157       }
1158       DU_FREE(fDD,sizeof(FDD_Info_t));
1159    }
1160 }
1161
1162 /*******************************************************************
1163  *
1164  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1165  *
1166  * @details
1167  *
1168  *    Function :  FreeServedCellList
1169  *
1170  *    Functionality:  deallocating the memory of function BuildServedCellList
1171
1172  *
1173  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1174  *
1175  * @return void
1176  *
1177  * ****************************************************************/
1178 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1179 {
1180    uint8_t   plmnCnt=MAX_PLMN;
1181    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1182    uint8_t  plmnIdx=0, sliceIdx=0;
1183    GNB_DU_Served_Cells_Item_t *srvCellItem;
1184    ServedPLMNs_Item_t  *servedPlmnItem;
1185    SliceSupportItem_t  *sliceSupportItem;
1186
1187    if(duServedCell->list.array!=NULLP)
1188    {
1189       if(duServedCell->list.array[0]!=NULLP)
1190       {
1191          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1192
1193          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1194                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1195          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1196                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1197
1198          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1199          {
1200             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1201                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1202             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1203          }
1204
1205          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1206          {
1207             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1208             {
1209                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1210                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1211
1212                if(servedPlmnItem->iE_Extensions != NULLP)
1213                {
1214                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1215                   {
1216                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1217                      {
1218                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1219                               SliceSupportList.list.array != NULLP)
1220                         {
1221                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1222                                  extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1223                            {
1224                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1225                                     SliceSupportList.list.array[sliceIdx] != NULLP)
1226                               {
1227                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1228                                                     extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1229
1230                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1231
1232                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1233                                  {
1234                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1235                                           sliceSupportItem->sNSSAI.sD->size);
1236                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1237                                  }
1238
1239                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1240                                        choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1241                               }
1242                            }
1243                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1244                                  SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1245                                  extensionValue.choice.SliceSupportList.list.size);
1246                         }
1247                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1248                               sizeof(ServedPLMNs_ItemExtIEs_t));
1249                      }
1250                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1251                            extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1252                   }
1253                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1254                }
1255                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1256                      sizeof(ServedPLMNs_Item_t));
1257             }
1258             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1259                   sizeof(ServedPLMNs_Item_t *));
1260          }
1261
1262          if(srvCellItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1263          {
1264             freeFddNrFreqInfo(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1265          }
1266          else
1267          {
1268             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD != NULLP)
1269             {
1270                freeTddNrFreqInfo(&srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1271                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1272             }
1273          }
1274
1275          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1276                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1277
1278          if(srvCellItem->gNB_DU_System_Information != NULLP)
1279          {
1280             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1281             {
1282                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1283                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1284             }
1285
1286             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1287             {
1288                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1289                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1290             }
1291
1292             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1293          }
1294
1295          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1296       }
1297       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1298    }
1299 }
1300
1301 /*******************************************************************
1302  *
1303  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1304  *
1305  * @details
1306  *
1307  *    Function :  FreeF1SetupReq
1308  *
1309  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1310  *
1311  * @params[in] F1AP_PDU_t *f1apMsg
1312  *
1313  * @return void
1314  *
1315  * ****************************************************************/
1316 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1317 {
1318    uint8_t ieIdx, ieIdx2;
1319    F1SetupRequest_t *f1SetupReq=NULLP;
1320
1321    if(f1apMsg != NULLP)
1322    {
1323       if(f1apMsg->choice.initiatingMessage != NULLP)
1324       {
1325          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1326          if(f1SetupReq->protocolIEs.list.array != NULLP)
1327          {
1328             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1329             {
1330                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1331                {
1332                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1333                   {
1334                      case ProtocolIE_ID_id_TransactionID:
1335                         break;
1336                      case ProtocolIE_ID_id_gNB_DU_ID:
1337                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1338                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1339                         break;
1340                      case ProtocolIE_ID_id_gNB_DU_Name:
1341                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1342                               strlen((char *)duCfgParam.duName));
1343                         break;
1344                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1345                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1346                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1347                         break;
1348                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1349                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1350                         break;
1351                      default:
1352                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1353                         break;
1354                   }
1355                }
1356             }
1357             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1358             {
1359                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1360             }
1361             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1362                   f1SetupReq->protocolIEs.list.size);
1363          }
1364          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1365       }
1366       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1367    }
1368 }
1369 /*******************************************************************
1370  *
1371  * @brief Builds and Send the F1SetupRequest
1372  *
1373  * @details
1374  *
1375  *    Function : BuildAndSendF1SetupReq
1376  *
1377  * Functionality:Fills the F1SetupRequest
1378  *
1379  * @return ROK     - success
1380  *         RFAILED - failure
1381  *
1382  ******************************************************************/
1383 uint8_t BuildAndSendF1SetupReq()
1384 {
1385    uint8_t   ret, ieIdx, elementCnt;
1386    F1AP_PDU_t                 *f1apMsg = NULLP;
1387    F1SetupRequest_t           *f1SetupReq=NULLP;
1388    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1389    RRC_Version_t              *rrcVer=NULLP;
1390    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1391    ret= RFAILED;
1392
1393    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1394    do
1395    {
1396       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1397       if(f1apMsg == NULLP)
1398       {
1399          break;
1400       }
1401       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1402       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1403       if(f1apMsg->choice.initiatingMessage == NULLP)
1404       {
1405          break;
1406       }
1407       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1408       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1409       f1apMsg->choice.initiatingMessage->value.present = \
1410                                                          InitiatingMessage__value_PR_F1SetupRequest;
1411
1412       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1413
1414       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1415
1416       f1SetupReq->protocolIEs.list.count = elementCnt;
1417       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1418
1419       /* Initialize the F1Setup members */
1420       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1421       if(f1SetupReq->protocolIEs.list.array == NULLP)
1422       {
1423          break;
1424       }
1425       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1426       {
1427          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1428                sizeof(F1SetupRequestIEs_t));
1429          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1430          {
1431             break;
1432          }
1433       }
1434
1435       ieIdx = 0;
1436       /*TransactionID*/
1437       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1438       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1439       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1440                                                                F1SetupRequestIEs__value_PR_TransactionID;
1441       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1442                                                                              TRANS_ID;
1443
1444       /*DU ID*/
1445       ieIdx++;
1446       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1447       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1448       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1449                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1450       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1451                                                                              sizeof(uint8_t);
1452
1453       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1454             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1455       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1456             NULLP)
1457       {
1458          break;
1459       }
1460
1461       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1462          duCfgParam.duId;
1463
1464       /*DU Name*/
1465       if(duCfgParam.duName != NULL)
1466       {
1467          ieIdx++;
1468          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1469          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1470          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1471          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1472             strlen((char *)duCfgParam.duName);
1473          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1474                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1475          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1476                buf == NULLP)
1477          {
1478             break;
1479          }
1480          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1481                choice.GNB_DU_Name.buf,
1482                (char*)&duCfgParam.duName);
1483
1484       }
1485
1486       /*Served Cell list */
1487       ieIdx++;
1488       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1489                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1490       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1491       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1492                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1493       duServedCell = &f1SetupReq->protocolIEs.list.\
1494                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1495       if(BuildServedCellList(duServedCell))
1496       {
1497          break;
1498       }
1499       /*RRC Version*/
1500       ieIdx++;
1501       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1502                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1503       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1504       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1505                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1506       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1507       if(BuildRrcVer(rrcVer))
1508       {
1509          break;
1510       }
1511       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1512
1513       /* Encode the F1SetupRequest type as APER */
1514       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1515       encBufSize = 0;
1516       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1517             encBuf);
1518
1519       /* Encode results */
1520       if(encRetVal.encoded == ENCODE_FAIL)
1521       {
1522          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1523                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1524          break;
1525       }
1526       else
1527       {
1528          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1529          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1530          {
1531             printf("%x",encBuf[ieIdx]);
1532          }
1533
1534          duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize;
1535          DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize);
1536          if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
1537          {
1538              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the encoding of f1setup req");
1539              return RFAILED;
1540          }
1541          memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
1542       }
1543
1544       /* Sending msg */
1545       if(sendF1APMsg() != ROK)
1546       {
1547          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1548          break;
1549       }
1550
1551       ret=ROK;
1552       break;
1553    }while(true);
1554
1555    FreeF1SetupReq(f1apMsg);
1556
1557    return ret;
1558 }/* End of BuildAndSendF1SetupReq */
1559
1560 /*******************************************************************
1561  *
1562  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1563  *
1564  * @details
1565  *
1566  *    Function : freeCellsToModifyItem
1567  *
1568  *    Functionality: Deallocating memory of variables allocated in
1569  *                    BuildAndSendDUConfigUpdate function
1570  *
1571  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1572  *
1573  * @return ROK     - void
1574  *
1575  * ****************************************************************/
1576
1577 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1578 {
1579    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1580    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1581    SliceSupportItem_t *sliceSupportItem = NULLP;
1582
1583    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1584    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1585
1586    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1587            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1588    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1589          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1590
1591    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1592    {
1593       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1594       {
1595          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1596
1597          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1598
1599          if(servedPlmnItem->iE_Extensions != NULLP)
1600          {
1601             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1602             {
1603                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1604                {
1605                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1606                         list.array != NULLP)
1607                   {
1608                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1609                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1610                      {
1611                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1612                               list.array[sliceLstIdx] != NULLP)
1613                         {
1614
1615                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1616                                               SliceSupportList.list.array[sliceLstIdx];
1617
1618                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1619                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1620                            {
1621                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1622                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1623                            }
1624                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1625                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1626                         }
1627                      }
1628                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1629                            choice.SliceSupportList.list.array,\
1630                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1631                            extensionValue.choice.SliceSupportList.list.size);
1632                   }
1633                }
1634                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1635                {
1636                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1637                }
1638                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1639             }
1640             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1641          }
1642       }
1643       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1644       {
1645          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1646       }
1647       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1648          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1649    }
1650
1651    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1652    {
1653       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1654    }
1655    else
1656    {
1657       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
1658       {
1659          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1660          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1661       }
1662    }
1663    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1664       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1665 }
1666
1667 /*******************************************************************
1668  *
1669  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1670  *
1671  * @details
1672  *
1673  *    Function : FreeDUConfigUpdate
1674  *
1675  *    Functionality: Deallocating memory of variables allocated in
1676  *                    BuildAndSendDUConfigUpdate function
1677  *
1678  * @params[in]  F1AP_PDU_t *f1apDuCfg
1679  *
1680  * @return ROK     - void
1681  *
1682  * ****************************************************************/
1683 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1684 {
1685    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1686    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1687    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1688    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1689    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1690    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1691
1692    if(f1apDuCfg != NULLP)
1693    {
1694       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1695       {
1696          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1697                        value.choice.GNBDUConfigurationUpdate;
1698          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1699          {
1700             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1701             {
1702                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1703                {
1704                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1705                   {
1706                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1707                         {
1708                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1709                                            value.choice.Served_Cells_To_Modify_List;
1710                            if(cellsToModify->list.array != NULLP)
1711                            {
1712                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1713                               {
1714                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1715                                  {
1716                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1717                                           Served_Cells_To_Modify_Item);
1718                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1719                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1720                                  }
1721                               }
1722                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1723                            }
1724                            break;
1725                         }
1726                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1727                         {
1728                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1729                                            value.choice.Served_Cells_To_Delete_List;
1730                            if(cellsToDelete->list.array != NULLP)
1731                            {
1732                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1733                               {
1734                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1735                                  {
1736                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1737                                           cellsToDelete->list.array[cellDeleteIdx]);
1738                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1739                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1740                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1741                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1742                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1743                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1744                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1745                                  }
1746                               }
1747                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1748                            }
1749
1750                            break;
1751                         }
1752                      case ProtocolIE_ID_id_gNB_DU_ID:
1753                         {
1754                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1755                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1756                            break;
1757                         }
1758                   }
1759                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1760                         sizeof(GNBDUConfigurationUpdateIEs_t));
1761                }
1762             }
1763             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1764          }
1765          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1766       }
1767       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1768    }
1769 }
1770
1771 /*******************************************************************
1772  *
1773  * @brief Fills Served Plmns required in ServCellInfo IE
1774  *
1775  * @details
1776  *
1777  *    Function : fillServedPlmns
1778  *
1779  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1780  *
1781  * @params[in] Pointer to ServedPLMNs_List_t *
1782  *
1783  * @return ROK     - success
1784  *         RFAILED - failure
1785  *
1786  *****************************************************************/
1787
1788 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1789 {
1790    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
1791
1792    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
1793    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
1794          array[arrayIdx]->pLMN_Identity.size);
1795    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
1796    {
1797       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1798       return RFAILED;
1799    }
1800    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
1801          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
1802    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1803    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
1804    {
1805       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1806       return RFAILED;
1807    }
1808
1809    ieListCnt=1;
1810    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
1811    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1812    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
1813          iE_Extensions->list.size);
1814    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
1815    {
1816       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1817       return RFAILED;
1818    }
1819    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
1820    {
1821       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
1822             sizeof(ServedPLMNs_ItemExtIEs_t));
1823       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
1824       {
1825          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1826          return RFAILED;
1827       }
1828    }
1829
1830    ieIdx = 0;
1831    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1832    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
1833    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
1834    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
1835    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1836    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1837       list.count = elementCnt;
1838    servedPlmn->list.array[arrayIdx]->\
1839       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1840       list.size = elementCnt * sizeof(SliceSupportItem_t *);
1841    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1842          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1843          list.array,servedPlmn->list.array[arrayIdx]->\
1844          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
1845    if(servedPlmn->list.array[arrayIdx]->\
1846          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1847          list.array == NULLP)
1848    {
1849       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1850       return RFAILED;
1851    }
1852
1853    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
1854    {
1855       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1856       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1857       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
1858       if(servedPlmn->list.array[arrayIdx]->\
1859       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1860       list.array[sliceLstIdx] == NULLP)
1861       {
1862          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1863          return RFAILED;
1864       }
1865
1866       servedPlmn->list.array[arrayIdx]->\
1867       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1868       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1869       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1870       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1871       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
1872       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
1873       sNSSAI.sST.size);
1874
1875       if(servedPlmn->list.array[arrayIdx]->\
1876       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1877       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1878       {
1879          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1880          return RFAILED;
1881       }
1882       servedPlmn->list.array[arrayIdx]->\
1883       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1884       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1885       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1886
1887       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1888       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1889       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1890       if(servedPlmn->list.array[arrayIdx]->\
1891       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1892       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1893       {
1894          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1895          return RFAILED;
1896       }
1897       servedPlmn->list.array[arrayIdx]->\
1898       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1899       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1900       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1901       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1902       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
1903       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1904       list.array[sliceLstIdx]->sNSSAI.sD->size);
1905       if(servedPlmn->list.array[arrayIdx]->\
1906       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1907       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1908       {
1909          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1910          return RFAILED;
1911       }
1912       memcpy(servedPlmn->list.array[arrayIdx]->\
1913       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1914       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1915       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
1916       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1917       list.array[sliceLstIdx]->sNSSAI.sD->size);
1918    }
1919    return ROK;
1920 }
1921
1922 /*******************************************************************
1923  *
1924  * @brief Fills Nr Fdd Info required in ServCellInfo IE
1925  *
1926  * @details
1927  *
1928  *    Function : fillNrFddInfo
1929  *
1930  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
1931  *
1932  * @params[in] FDD_Info_t *fDD
1933  *
1934  * @return ROK     - success
1935  *         RFAILED - failure
1936  *
1937  *****************************************************************/
1938
1939 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
1940 {
1941    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1942       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1943    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
1944    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1945    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1946          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1947    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1948    {
1949       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1950       return RFAILED;
1951    }
1952
1953    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
1954       sizeof(FreqBandNrItem_t));
1955    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1956    {
1957       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1958       return RFAILED;
1959    }
1960
1961    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1962       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
1963       freqBand[0].nrFreqBand;
1964    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1965    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
1966       dlNrFreqInfo.nrArfcn;
1967    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
1968    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
1969    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1970    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1971    {
1972       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1973       return RFAILED;
1974    }
1975
1976    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
1977    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1978    {
1979       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1980       return RFAILED;
1981    }
1982
1983    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1984       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
1985       freqBand[0].nrFreqBand;
1986    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1987
1988    /*Transmission Bandwidth*/
1989    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1990       f1Mode.mode.fdd.ulTxBw.nrScs;
1991    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1992       f1Mode.mode.fdd.ulTxBw.nrb;
1993    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1994       f1Mode.mode.fdd.dlTxBw.nrScs;
1995    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1996       f1Mode.mode.fdd.dlTxBw.nrb;
1997
1998    return ROK;
1999 }
2000
2001 /*******************************************************************
2002  *
2003  * @brief Fills ServCellInfo IE
2004  *
2005  * @details
2006  *
2007  *    Function : fillServedCellInfo
2008  *
2009  *    Functionality: Fills ServCellInfo
2010  *
2011  * @params[in] Pointer to Served_Cell_Information_t *
2012  *
2013  * @return ROK     - success
2014  *         RFAILED - failure
2015  *
2016  *****************************************************************/
2017
2018 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2019 {
2020    uint8_t ieIdx, ieListCnt;
2021
2022    /*nRCGI*/
2023    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2024    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2025          srvCellInfo->nRCGI.pLMN_Identity.size);
2026    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2027    {
2028       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2029       return RFAILED;
2030    }
2031    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2032          srvCellInfo->nRCGI.pLMN_Identity.buf);
2033    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2034    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2035          srvCellInfo->nRCGI.nRCellIdentity.size);
2036    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2037    {
2038       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2039       return RFAILED;
2040    }
2041
2042    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2043    /*nRPCI*/
2044    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2045
2046    /*servedPLMNs*/
2047    ieListCnt = 1;
2048    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2049    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2050    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2051    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2052    {
2053       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2054       return RFAILED;
2055    }
2056    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2057    {
2058       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2059       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2060       {
2061          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2062          return RFAILED;
2063       }
2064    }
2065    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2066    {
2067       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2068       return RFAILED;
2069    }
2070
2071 #ifndef NR_TDD
2072    /*nR Mode Info with FDD*/
2073    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2074    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2075    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2076    {
2077       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2078       return RFAILED;
2079    }
2080    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2081    {
2082        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2083       return RFAILED;
2084    }
2085 #else
2086    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2087    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2088    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2089    {
2090       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2091       return RFAILED;
2092    }
2093    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2094    {
2095       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2096       return RFAILED;
2097    }
2098 #endif
2099
2100    /*Measurement timing Config*/
2101    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2102    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2103          buf,srvCellInfo->measurementTimingConfiguration.size);
2104    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2105    {
2106       return RFAILED;
2107    }
2108    srvCellInfo->measurementTimingConfiguration.\
2109          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2110
2111    return ROK;
2112 }
2113
2114 /*******************************************************************
2115  *
2116  * @brief Fills ServCellToModItem IE
2117  *
2118  * @details
2119  *
2120  *    Function : fillServCellToModItem
2121  *
2122  *    Functionality: Fills ServCellToModItem IE
2123  *
2124  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2125  *
2126  * @return ROK     - success
2127  *         RFAILED - failure
2128  *
2129  *****************************************************************/
2130
2131 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2132 {
2133    /*pLMN_Identity*/
2134    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2135    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2136    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2137    {
2138       return RFAILED;
2139    }
2140    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2141          modifyItem->oldNRCGI.pLMN_Identity.buf);
2142
2143    /*nRCellIdentity*/
2144    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2145    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2146          modifyItem->oldNRCGI.nRCellIdentity.size);
2147    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2148    {
2149       return RFAILED;
2150    }
2151    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2152
2153    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2154       return RFAILED;
2155    else
2156       return ROK;
2157 }
2158
2159 /*******************************************************************
2160  *
2161  * @brief Builds ServCellToModList
2162  *
2163  * @details
2164  *
2165  *    Function : buildServCellToModList
2166  *
2167  *    Functionality: Builds the serv cell to Mod List
2168  *
2169  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2170  *
2171  * @return ROK     - success
2172  *         RFAILED - failure
2173  *
2174  *****************************************************************/
2175
2176 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2177 {
2178    uint8_t ieListCnt, ieIdx;
2179    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2180
2181    ieListCnt = 1;
2182    cellsToModify->list.count = ieListCnt;
2183    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2184    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2185    if(cellsToModify->list.array == NULLP)
2186    {
2187       return RFAILED;
2188    }
2189    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2190    {
2191       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2192       if(cellsToModify->list.array[ieIdx] == NULLP)
2193       {
2194          return RFAILED;
2195       }
2196    }
2197    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2198    cellsToModify->list.array[0]->criticality = Criticality_reject;
2199    cellsToModify->list.array[0]->value.present =\
2200       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2201    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2202
2203    if(fillServCellToModItem(modifyItem))
2204       return RFAILED;
2205    else
2206       return ROK;
2207 }
2208 /*******************************************************************
2209  *
2210  * @brief filling the DeleteItemList
2211  *
2212  * @details
2213  *
2214  *    Function : fillCellToDeleteItem
2215  *
2216  *    Functionality: Filling the DeleteItemIe
2217  *
2218  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2219  *
2220  * @return ROK     - success
2221  *         RFAILED - failure
2222  *
2223  *****************************************************************/
2224 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2225 {
2226    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2227
2228    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2229    deleteItemIe->criticality = Criticality_reject;
2230    deleteItemIe->value.present =\
2231    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2232    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2233
2234    /*pLMN_Identity*/
2235    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2236    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2237    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2238    {
2239       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2240       return RFAILED;
2241    }
2242    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2243          deleteItem->oldNRCGI.pLMN_Identity.buf);
2244
2245    /*nRCellIdentity*/
2246    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2247    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2248          deleteItem->oldNRCGI.nRCellIdentity.size);
2249    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2250    {
2251       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2252       return RFAILED;
2253    }
2254    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2255    return ROK;
2256 }
2257 /*******************************************************************
2258  *
2259  * @brief Builds ServCellToDeleteList
2260  *
2261  * @details
2262  *
2263  *    Function : buildServCellToDeleteList
2264  *
2265  *    Functionality: Builds the serv cell to delete List
2266  *
2267  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2268  *
2269  * @return ROK     - success
2270  *         RFAILED - failure
2271  *
2272  *****************************************************************/
2273
2274 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2275 {
2276    uint8_t ieListCnt, arrIdx;
2277
2278    ieListCnt = 1;
2279    cellsToDelete->list.count = ieListCnt;
2280    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2281
2282    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2283    if(cellsToDelete->list.array == NULLP)
2284    {
2285       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2286       return RFAILED;
2287    }
2288
2289    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2290    {
2291       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2292       if(cellsToDelete->list.array[arrIdx] == NULLP)
2293       {
2294          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2295          return RFAILED;
2296       }
2297    }
2298
2299    arrIdx=0;
2300    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2301    {
2302       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2303       return RFAILED;
2304    }
2305    return ROK;
2306 }
2307
2308 /*******************************************************************
2309  *
2310  * @brief Builds and sends the DUConfigUpdate
2311  *
2312  * @details
2313  *
2314  *    Function : BuildAndSendDUConfigUpdate
2315  *
2316  *    Functionality: Constructs the DU Update message and sends
2317  *                   it to the CU through SCTP.
2318  *
2319  * @params[in] void **buf,Buffer to which encoded pattern is written into
2320  * @params[in] int *size,size of buffer
2321  *
2322  * @return ROK     - success
2323  *         RFAILED - failure
2324  *
2325  * ****************************************************************/
2326 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2327 {
2328    uint8_t ret =0, ieIdx=0, elementCnt=0;
2329    bool memAlloctionFailure = false;
2330    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2331    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2332    asn_enc_rval_t encRetVal;     /* Encoder return value */
2333
2334    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2335    ret= RFAILED;
2336
2337    while(true)
2338    {
2339       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2340       /* Allocate the memory for F1DuCfg */
2341       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2342       if(f1apDuCfg == NULLP)
2343       {
2344          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2345          break;
2346       }
2347
2348       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2349       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2350       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2351       {
2352          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2353          break;
2354       }
2355
2356       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2357                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2358       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2359       f1apDuCfg->choice.initiatingMessage->value.present = \
2360                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2361       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2362                     choice.GNBDUConfigurationUpdate;
2363       elementCnt = 3;
2364       duCfgUpdate->protocolIEs.list.count = elementCnt;
2365       duCfgUpdate->protocolIEs.list.size = \
2366                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2367
2368       /* Initialize the F1Setup members */
2369       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2370       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2371       {
2372          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2373          break;
2374       }
2375       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2376       {
2377          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2378          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2379          {
2380             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2381             memAlloctionFailure = true;
2382             break;
2383          }
2384       }
2385
2386       if(memAlloctionFailure == true)
2387       {
2388          break;
2389       }
2390       /*TransactionID*/
2391       ieIdx = 0;
2392       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2393       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2394       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2395       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2396       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2397
2398       ieIdx++;
2399       if(servCellAction == SERV_CELL_TO_MODIFY)
2400       {
2401          /*Served Cell to Modify */
2402          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2403          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2404          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2405          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2406          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2407          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2408                   Served_Cells_To_Modify_List))
2409          {
2410             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2411             break;
2412          }
2413       }
2414       else
2415       {
2416          /*Served Cell to Delete */
2417          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2418          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2419          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2420          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2421          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2422          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2423          Served_Cells_To_Delete_List)!=ROK)
2424          {
2425             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2426             break;
2427          }
2428
2429       }
2430       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2431       /*GNB DU ID */
2432       ieIdx++;
2433       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2434       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2435       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2436       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2437       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2438       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2439             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2440       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2441       {
2442          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2443          break;
2444       }
2445       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2446
2447       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2448
2449       /* Encode the DU Config Update type as APER */
2450       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2451       encBufSize = 0;
2452       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2453
2454       /* Checking encode results */
2455       if(encRetVal.encoded == ENCODE_FAIL)
2456       {
2457          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2458                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2459          break;
2460       }
2461       else
2462       {
2463          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2464          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2465          {
2466             printf("%x",encBuf[ieIdx]);
2467          }
2468       }
2469       /* Sending msg */
2470       if(sendF1APMsg() != ROK)
2471       {
2472          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2473          break;
2474       }
2475
2476       ret = ROK;
2477       break;
2478    }
2479
2480    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2481    return ret;
2482 }
2483
2484
2485 /*******************************************************************
2486  *
2487  * @brief free the ULRRCMessageTransfer
2488  *
2489  * @details
2490  *
2491  *    Function : FreeULRRCMessageTransfer
2492  *
2493  *    Functionality: Deallocating the memory of variable allocated in
2494  *                      FreeULRRCMessageTransfer
2495  *
2496  * @params[in]
2497  *
2498  * @return ROK     - void
2499  *
2500  ******************************************************************/
2501 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2502 {
2503    uint8_t idx1;
2504    ULRRCMessageTransfer_t  *ulRRCMsg;
2505
2506    if(f1apMsg != NULLP)
2507    {
2508       if(f1apMsg->choice.initiatingMessage != NULLP)
2509       {
2510          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2511          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2512          {
2513             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2514             {
2515                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2516                {
2517                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2518                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2519                   {
2520                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2521                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2522                   }
2523                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2524                }
2525             }
2526             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2527          }
2528          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2529       }
2530       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2531    }
2532 }
2533 /*******************************************************************
2534  *
2535  * @brief Builds and sends the ULRRCMessageTransfer
2536  *
2537  * @details
2538  *
2539  *    Function : BuildAndSendULRRCMessageTransfer
2540  *
2541  *    Functionality: Constructs the UL RRC Message Transfer and sends
2542  *                   it to the CU through SCTP.
2543  *
2544  * @params[in]
2545  *
2546  * @return ROK     - success
2547  *         RFAILED - failure
2548  *
2549  * ****************************************************************/
2550 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2551       uint16_t msgLen, uint8_t *rrcMsg)
2552 {
2553    uint8_t   elementCnt =0;
2554    uint8_t   idx1 =0;
2555    uint8_t   idx =0;
2556    F1AP_PDU_t                   *f1apMsg = NULLP;
2557    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2558    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2559    uint8_t ret =RFAILED;
2560
2561    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2562
2563    while(true)
2564    {
2565       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2566
2567       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2568       if(f1apMsg == NULLP)
2569       {
2570          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2571          break;
2572       }
2573       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2574       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2575       if(f1apMsg->choice.initiatingMessage == NULLP)
2576       {
2577          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2578          break;
2579       }
2580       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2581       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2582       f1apMsg->choice.initiatingMessage->value.present = \
2583                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2584       ulRRCMsg =
2585          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2586       elementCnt = 4;
2587       ulRRCMsg->protocolIEs.list.count = elementCnt;
2588       ulRRCMsg->protocolIEs.list.size = \
2589                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2590
2591       /* Initialize the F1Setup members */
2592       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2593       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2594       {
2595          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2596          break;
2597       }
2598       for(idx=0; idx<elementCnt; idx++)
2599       {
2600          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2601          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2602          {
2603             break;
2604          }
2605       }
2606
2607       idx1 = 0;
2608
2609       /*GNB CU UE F1AP ID*/
2610       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2611       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2612       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2613                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2614       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2615
2616       /*GNB DU UE F1AP ID*/
2617       idx1++;
2618       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2619       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2620       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2621                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2622       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2623
2624       /*SRBID*/
2625       idx1++;
2626       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2627       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2628       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2629                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2630       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2631
2632       /*RRCContainer*/
2633       idx1++;
2634       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2635       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2636       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2637                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2638       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2639       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2640             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2641       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2642       {
2643          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2644          break;
2645       }
2646       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2647       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2648             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2649
2650       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2651
2652       /* Encode the F1SetupRequest type as APER */
2653       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2654       encBufSize = 0;
2655       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2656             encBuf);
2657       /* Encode results */
2658       if(encRetVal.encoded == ENCODE_FAIL)
2659       {
2660          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2661                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2662          break;
2663       }
2664       else
2665       {
2666          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2667          for(int i=0; i< encBufSize; i++)
2668          {
2669             printf("%x",encBuf[i]);
2670          }
2671       }
2672
2673       /* Sending  msg  */
2674       if(sendF1APMsg()  !=      ROK)
2675       {
2676          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2677          break;
2678       }
2679       ret = ROK;
2680       break;
2681    }
2682    FreeULRRCMessageTransfer(f1apMsg);
2683
2684    return ret;
2685 }/* End of BuildAndSendULRRCMessageTransfer*/
2686
2687 /*******************************************************************
2688  *
2689  * @brief Builds tag config
2690  *
2691  * @details
2692  *
2693  *    Function : BuildTagConfig
2694  *
2695  *    Functionality: Builds tag config in MacCellGroupConfig
2696  *
2697  * @params[in] TAG_Config *tag_Config
2698  *
2699  * @return ROK     - success
2700  *         RFAILED - failure
2701  *
2702  * ****************************************************************/
2703 uint8_t BuildTagConfig(DuUeCb *ueCb, struct TAG_Config *tagConfig)
2704 {
2705    struct TAG_Config__tag_ToAddModList *tagList;
2706    uint8_t                     idx, elementCnt;
2707
2708    tagConfig->tag_ToReleaseList = NULLP;
2709    tagConfig->tag_ToAddModList = NULLP;
2710    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2711    if(!tagConfig->tag_ToAddModList)
2712    {
2713       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2714       return RFAILED;
2715    }
2716
2717    if(ueCb == NULLP)
2718       elementCnt = ODU_VALUE_ONE;
2719    else
2720       elementCnt = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModListCount;
2721
2722    tagList = tagConfig->tag_ToAddModList;
2723    tagList->list.count = elementCnt;
2724    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2725
2726    tagList->list.array = NULLP;
2727    DU_ALLOC(tagList->list.array, tagList->list.size);
2728    if(!tagList->list.array)
2729    {
2730       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2731       return RFAILED;
2732    }
2733
2734    for(idx=0; idx<tagList->list.count; idx++)
2735    {
2736       tagList->list.array[idx] = NULLP;
2737       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2738       if(!tagList->list.array[idx])
2739       {
2740          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2741          return RFAILED;
2742       }
2743    }
2744
2745    if(ueCb == NULLP)
2746    {
2747       idx = 0;
2748       tagList->list.array[idx]->tag_Id = TAG_ID;
2749       tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2750    }
2751    else
2752    {
2753       for(idx=0; idx<tagList->list.count; idx++)
2754       {
2755          tagList->list.array[idx]->tag_Id = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].tagId;
2756          tagList->list.array[idx]->timeAlignmentTimer = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].timeAlignTimer;
2757       }
2758    }
2759
2760    return ROK;
2761 }
2762
2763 /*******************************************************************
2764  *
2765  * @brief Builds PHR Config
2766  *
2767  * @details
2768  *
2769  *    Function : BuildPhrConfig
2770  *
2771  *    Functionality: Builds phrConfig in MacCellGroupConfig
2772  *
2773  * @params[in] PHR Config *
2774  *
2775  * @return ROK     - success
2776  *         RFAILED - failure
2777  *
2778  * ****************************************************************/
2779 uint8_t BuildPhrConfig(DuUeCb *ueCb, struct MAC_CellGroupConfig__phr_Config *phrConfig)
2780 {
2781
2782    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2783    phrConfig->choice.setup = NULLP;
2784    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2785    if(!phrConfig->choice.setup)
2786    {
2787       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2788       return RFAILED;
2789    }
2790
2791    if(ueCb == NULLP)
2792    {
2793       phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2794       phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2795       phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2796       phrConfig->choice.setup->multiplePHR              = false;
2797       phrConfig->choice.setup->dummy                    = false;
2798       phrConfig->choice.setup->phr_Type2OtherCell       = false;
2799       phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2800    }
2801    else
2802    {
2803       phrConfig->choice.setup->phr_PeriodicTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.periodicTimer;
2804       phrConfig->choice.setup->phr_ProhibitTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.prohibitTimer;
2805       phrConfig->choice.setup->phr_Tx_PowerFactorChange = ueCb->macUeCfg.macCellGrpCfg.phrCfg.txPowerFactor;
2806       phrConfig->choice.setup->multiplePHR              = ueCb->macUeCfg.macCellGrpCfg.phrCfg.multiplePHR;
2807       phrConfig->choice.setup->dummy                    = ueCb->macUeCfg.macCellGrpCfg.phrCfg.dummy;
2808       phrConfig->choice.setup->phr_Type2OtherCell       = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrType2OtherCell;
2809       phrConfig->choice.setup->phr_ModeOtherCG          = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrOtherCG;
2810    }
2811
2812    return ROK;
2813 }
2814
2815 /*******************************************************************
2816  *
2817  * @brief Builds BSR Config
2818  *
2819  * @details
2820  *
2821  *    Function : BuildBsrConfig
2822  *
2823  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2824  *
2825  * @params[in] BSR_Config *bsrConfig
2826  *
2827  * @return ROK     - success
2828  *         RFAILED - failure
2829  *
2830  * ****************************************************************/
2831 uint8_t BuildBsrConfig(DuUeCb *ueCb, struct BSR_Config *bsrConfig)
2832 {
2833    if(ueCb == NULLP)
2834    {
2835       bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2836       bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2837       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2838    }
2839    else
2840    {
2841       bsrConfig->periodicBSR_Timer = convertBsrPeriodicTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.periodicTimer);
2842       bsrConfig->retxBSR_Timer     = convertBsrRetxTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.retxTimer);
2843
2844       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2845       DU_ALLOC(bsrConfig->logicalChannelSR_DelayTimer, sizeof(long));
2846       if(bsrConfig->logicalChannelSR_DelayTimer == NULLP)
2847       {
2848          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildBsrConfig");
2849          return RFAILED;
2850       }
2851       *(bsrConfig->logicalChannelSR_DelayTimer) = convertLcSrDelayTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.srDelayTimer);
2852    }
2853
2854    return ROK;
2855 }
2856
2857 /*******************************************************************
2858  *
2859  * @brief Builds scheduling request config
2860  *
2861  * @details
2862  *
2863  *    Function : BuildSchedulingReqConfig
2864  *
2865  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2866  *
2867  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2868  *
2869  * @return ROK     - success
2870  *         RFAILED - failure
2871  *
2872  * ****************************************************************/
2873 uint8_t BuildSchedulingReqConfig(DuUeCb *ueCb, struct SchedulingRequestConfig *schedulingRequestConfig)
2874 {
2875    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2876    uint8_t                     idx, elementCnt;
2877
2878    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2879    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2880          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2881    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2882    {
2883       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2884       return RFAILED;
2885    }
2886
2887    if(ueCb == NULLP)
2888       elementCnt = ODU_VALUE_ONE;
2889    else
2890       elementCnt = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModListCount;
2891
2892    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2893    schReqList->list.count = elementCnt;
2894    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2895
2896    schReqList->list.array = NULLP;
2897    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2898    if(!schReqList->list.array)
2899    {
2900       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2901       return RFAILED;
2902    }
2903
2904    for(idx=0; idx<schReqList->list.count; idx++)
2905    {
2906       schReqList->list.array[idx] = NULLP;
2907       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2908       if(!schReqList->list.array[idx])
2909       {
2910          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2911          return RFAILED;
2912       }
2913    }
2914
2915    if(ueCb == NULLP)
2916    {
2917       idx = 0;
2918       schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2919
2920       schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2921       DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2922       if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2923       {
2924          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2925          return RFAILED;
2926       }
2927       *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2928       schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2929    }
2930    else
2931    {
2932       for(idx=0; idx<schReqList->list.count; idx++)
2933       {
2934          schReqList->list.array[idx]->schedulingRequestId = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].schedReqId;
2935
2936          schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2937          DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2938          if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2939          {
2940             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2941             return RFAILED;
2942          }
2943          *(schReqList->list.array[idx]->sr_ProhibitTimer) = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srProhibitTmr;
2944          schReqList->list.array[idx]->sr_TransMax = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srTransMax;
2945       }
2946    }
2947
2948    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2949
2950    return ROK;
2951 }
2952
2953 /*******************************************************************
2954  *
2955  * @brief Builds RLC Configuration for AM mode
2956  *
2957  * @details
2958  *
2959  *    Function : BuildRlcConfigAm
2960  *
2961  *    Functionality:
2962  *       Builds AM mode RLC Config in BuildRlcBearerToAddModList
2963  *
2964  * @params[in] AmBearerCfg *amCfg
2965  *             RLC_Config_t  *rlcConfig
2966  *
2967  * @return ROK     - success
2968  *         RFAILED - failure
2969  *
2970  * ****************************************************************/
2971 uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig)
2972 {
2973    rlcConfig->choice.am = NULLP;
2974    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2975    if(!rlcConfig->choice.am)
2976    {
2977       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
2978       return RFAILED;
2979    }
2980
2981    /* Fill AM UL configuration */
2982    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2983    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2984    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2985    {
2986       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
2987       return RFAILED;
2988    }
2989
2990    /* Fill default AM UL configuration if input pointer to DU database is NULL */
2991    if(amCfg == NULLP)
2992    {
2993       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2994       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2995       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2996       rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2997       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2998    }
2999    else
3000    {
3001       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->dlAmCfg.snLenDl);
3002       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = covertPollRetxTmrValueToEnum(amCfg->dlAmCfg.pollRetxTmr);
3003       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = covertPollPduValueToEnum(amCfg->dlAmCfg.pollPdu);
3004       rlcConfig->choice.am->ul_AM_RLC.pollByte          = covertPollByteValueToEnum(amCfg->dlAmCfg.pollByte);
3005       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = covertMaxRetxValueToEnum(amCfg->dlAmCfg.maxRetxTh);
3006    }
3007
3008    /* Fill AM DL configuraion */
3009    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3010    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3011    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3012    {
3013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3014       return RFAILED;
3015    }
3016
3017    /* Fill default AM DL configuration if input pointer to DU database is NULL */
3018    if(amCfg == NULLP)
3019    {
3020       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3021       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3022       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3023    }
3024    else /* Fill AM configuration from DU database */
3025    {
3026       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->ulAmCfg.snLenUl);
3027       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = convertReasmblTmrValueToEnum(amCfg->ulAmCfg.reAssemTmr);
3028       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = convertProhibitTmrValueToEnum(amCfg->ulAmCfg.statProhTmr);
3029    }
3030    return ROK;
3031 }
3032
3033 /*******************************************************************
3034  *
3035  * @brief Builds RLC Config for UM Bidirection
3036  *
3037  * @details
3038  *
3039  *    Function : BuildRlcConfig UmBiDir
3040  *
3041  *    Functionality:
3042  *       Builds RLC Config for UM Bidirection in BuildRlcBearerToAddModList
3043  *
3044  * @params[in] UmBiDirBearerCfg *umBiDirCfg
3045  *             RLC_Config_t *rlcConfig
3046  *
3047  * @return ROK     - success
3048  *         RFAILED - failure
3049  *
3050  * ****************************************************************/
3051 uint8_t BuildRlcConfigUmBiDir(UmBiDirBearerCfg *umBiDirCfg, struct RLC_Config *rlcConfig)
3052 {
3053    rlcConfig->choice.um_Bi_Directional = NULLP;
3054    DU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
3055    if(rlcConfig->choice.um_Bi_Directional == NULLP)
3056    {
3057       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3058       return RFAILED;
3059    }
3060
3061    /* Fill UM Bidirectional UL configuration */
3062    rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
3063    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3064    if(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength == NULLP)
3065    {
3066       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3067       return RFAILED;
3068    }
3069
3070    if(umBiDirCfg != NULLP)
3071    {
3072       *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->dlUmCfg.snLenDlUm);
3073    }
3074
3075    /* Fill UM Bidirectional DL configuration */
3076    rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
3077    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3078    if(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength == NULLP)
3079    {
3080       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3081       return RFAILED;
3082    }
3083
3084    if(umBiDirCfg != NULLP)
3085    {
3086       *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->ulUmCfg.snLenUlUm);
3087       rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umBiDirCfg->ulUmCfg.reAssemTmr);
3088    }
3089
3090    return ROK;
3091 }
3092
3093 /*******************************************************************
3094  *
3095  * @brief Builds RLC Config for UM Uni directional UL
3096  *
3097  * @details
3098  *
3099  *    Function : BuildRlcConfigUmUniDirUl
3100  *
3101  *    Functionality:
3102  *       Builds RLC Config for UM Unidirection UL in BuildRlcBearerToAddModList
3103  *
3104  * @params[in] UmUniDirDlBearerCfg *umUniDirDlCfg
3105  *             RLC_Config_t *rlcConfig
3106  *
3107  * @return ROK     - success
3108  *         RFAILED - failure
3109  *
3110  * ****************************************************************/
3111 uint8_t BuildRlcConfigUmUniDirUl(UmUniDirDlBearerCfg *umUniDirDlCfg, RLC_Config_t *rlcConfig)
3112 {
3113    rlcConfig->choice.um_Uni_Directional_UL = NULLP;
3114    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
3115    if(rlcConfig->choice.um_Uni_Directional_UL == NULLP)
3116    {
3117       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3118       return RFAILED;
3119    }
3120
3121    rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength = NULLP;
3122    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3123    if(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength == NULLP)
3124    {
3125       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3126       return RFAILED;
3127    }
3128
3129    if(umUniDirDlCfg != NULLP)
3130    {
3131       *(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirDlCfg->dlUmCfg.snLenDlUm);
3132    }
3133
3134    return ROK;
3135 }
3136
3137 /*******************************************************************
3138  *
3139  * @brief Builds RLC Config for UM Uni directional DL
3140  *
3141  * @details
3142  *
3143  *    Function : BuildRlcConfigUmUniDirDl
3144  *
3145  *    Functionality:
3146  *       Builds RLC Config for UM Unidirection DL in BuildRlcBearerToAddModList
3147  *
3148  * @params[in] UmUniDirUlBearerCfg *umUniDirUlCfg
3149  *             RLC_Config_t *rlcConfig
3150  *
3151  * @return ROK     - success
3152  *         RFAILED - failure
3153  *
3154  * ****************************************************************/
3155 uint8_t BuildRlcConfigUmUniDirDl(UmUniDirUlBearerCfg *umUniDirUlCfg, RLC_Config_t *rlcConfig)
3156 {
3157    rlcConfig->choice.um_Uni_Directional_DL = NULLP;
3158    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
3159    if(rlcConfig->choice.um_Uni_Directional_DL == NULLP)
3160    {
3161       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3162       return RFAILED;
3163    }
3164
3165    rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength = NULLP;
3166    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3167    if(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength == NULLP)
3168    {
3169       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3170       return RFAILED;
3171    }
3172
3173    if(umUniDirUlCfg != NULLP)
3174    {
3175       *(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirUlCfg->ulUmCfg.snLenUlUm);
3176       rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umUniDirUlCfg->ulUmCfg.reAssemTmr);
3177    }
3178
3179    return ROK;
3180 }
3181
3182 /*******************************************************************
3183  *
3184  * @brief Builds RLC Config
3185  *
3186  * @details
3187  *
3188  *    Function : BuildRlcConfig
3189  *
3190  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3191  *
3192  * @params[in] RLC_Config_t *rlcConfig
3193  *
3194  * @return ROK     - success
3195  *         RFAILED - failure
3196  *
3197  * ****************************************************************/
3198 uint8_t BuildRlcConfig(RlcBearerCfg *rbCfg, struct RLC_Config *rlcConfig)
3199 {
3200
3201    /* Fill default values if rbCfg is NULL */
3202    if(rbCfg == NULLP)
3203    {
3204       rlcConfig->present = RLC_Config_PR_am;
3205       BuildRlcConfigAm(NULLP, rlcConfig);
3206    }
3207    /* If RbCfg is present, fill RLC configurations from DU Database */
3208    else
3209    {
3210       rlcConfig->present = covertRlcModeFromIntEnumToRrcEnum(rbCfg->rlcMode);
3211       switch(rlcConfig->present)
3212       {
3213          case RLC_Config_PR_am:
3214             BuildRlcConfigAm(rbCfg->u.amCfg, rlcConfig);
3215             break;
3216          case RLC_Config_PR_um_Bi_Directional:
3217             BuildRlcConfigUmBiDir(rbCfg->u.umBiDirCfg, rlcConfig);
3218             break;
3219          case RLC_Config_PR_um_Uni_Directional_UL:
3220             BuildRlcConfigUmUniDirUl(rbCfg->u.umUniDirDlCfg, rlcConfig);
3221             break;
3222          case RLC_Config_PR_um_Uni_Directional_DL:
3223             BuildRlcConfigUmUniDirDl(rbCfg->u.umUniDirUlCfg, rlcConfig);
3224             break;
3225          case RLC_Config_PR_NOTHING:
3226          default:
3227             break;
3228       }
3229    }
3230
3231    return ROK;
3232 }
3233
3234 /*******************************************************************
3235  *
3236  * @brief Builds MAC LC Config
3237  *
3238  * @details
3239  *
3240  *    Function : BuildMacLCConfig
3241  *
3242  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3243  *
3244  * @params[in] struct LogicalChannelConfig macLcConfig
3245  *
3246  * @return ROK     - success
3247  *         RFAILED - failure
3248  *
3249  * ****************************************************************/
3250 uint8_t BuildMacLCConfig(LcCfg *lcCfgDb, struct LogicalChannelConfig *macLcConfig)
3251 {
3252    macLcConfig->ul_SpecificParameters = NULLP;
3253    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3254    if(!macLcConfig->ul_SpecificParameters)
3255    {
3256       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3257       return RFAILED;
3258    }
3259
3260    if(lcCfgDb == NULLP)
3261    {
3262       macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3263       macLcConfig->ul_SpecificParameters->prioritisedBitRate =  PRIORTISIED_BIT_RATE;
3264       macLcConfig->ul_SpecificParameters->bucketSizeDuration =  BUCKET_SIZE_DURATION;
3265    }
3266    else
3267    {
3268       macLcConfig->ul_SpecificParameters->priority = lcCfgDb->ulLcCfg.priority;
3269       macLcConfig->ul_SpecificParameters->prioritisedBitRate = lcCfgDb->ulLcCfg.pbr;
3270       macLcConfig->ul_SpecificParameters->bucketSizeDuration = lcCfgDb->ulLcCfg.bsd;
3271    }
3272
3273    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3274    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3275    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3276    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3277
3278    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3279    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3280    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3281    {
3282       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3283       return RFAILED;
3284    }
3285
3286    if(lcCfgDb == NULLP)
3287       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3288    else
3289       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = lcCfgDb->ulLcCfg.lcGroup;
3290
3291    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3292    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3293    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3294    {
3295       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3296       return RFAILED;
3297    }
3298
3299    if(lcCfgDb == NULLP)
3300       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3301    else
3302       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = lcCfgDb->ulLcCfg.schReqId;
3303
3304    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3305    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3306    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3307
3308    return ROK;
3309 }
3310
3311 /*******************************************************************
3312  *
3313  * @brief Builds RLC Bearer to Add/Mod list
3314  *
3315  * @details
3316  *
3317  *    Function :BuildRlcBearerToAddModList
3318  *
3319  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3320  *
3321  * @params[in] rlc_BearerToAddModList
3322  *
3323  * @return ROK     - success
3324  *         RFAILED - failure
3325  *
3326  * ****************************************************************/
3327 uint8_t BuildRlcBearerToAddModList(DuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3328 {
3329    uint8_t  idx = 0, lcIdx=0, macLcIdx = 0, elementCnt = 0;
3330
3331    if(ueCb == NULLP)
3332       elementCnt = 1;
3333    else if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
3334       elementCnt = ueCb->rlcUeCfg.numLcs;
3335    else
3336    {
3337       for(lcIdx = 0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3338       {
3339          if(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == false)
3340             elementCnt++;
3341       }
3342    }
3343    rlcBearerList->list.count = elementCnt;
3344    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3345
3346    rlcBearerList->list.array = NULLP;
3347    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3348    if(!rlcBearerList->list.array)
3349    {
3350       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3351       return RFAILED;
3352    }
3353
3354    for(idx=0; idx<rlcBearerList->list.count; idx++)
3355    {
3356       rlcBearerList->list.array[idx] = NULLP;
3357       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3358       if(!rlcBearerList->list.array[idx])
3359       {
3360          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3361          return RFAILED;
3362       }
3363    }
3364
3365    if(ueCb == NULLP)
3366    {
3367       idx=0;
3368       rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3369       DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3370       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3371       {
3372          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3373          return RFAILED;
3374       }
3375       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3376       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB1_LCID;
3377       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3378
3379       /* Fill RLC related Configurations for this Radio Bearer */
3380       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3381       DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3382       if(!rlcBearerList->list.array[idx]->rlc_Config)
3383       {
3384          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3385          return RFAILED;
3386       }
3387       if(BuildRlcConfig(NULLP, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3388       {
3389          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3390          return RFAILED;
3391       }
3392
3393       /* Fill MAC related configurations for this Radio Bearer */
3394       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3395       DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3396       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3397       {
3398          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3399          return RFAILED;
3400       }
3401       if(BuildMacLCConfig(NULLP, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3402       {
3403          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3404          return RFAILED;
3405       }
3406    }
3407    else
3408    {
3409       idx=0;
3410       for(lcIdx=0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3411       {
3412          if((ueCb->f1UeDb->actionType != UE_CTXT_CFG_QUERY) && (ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == true))
3413             continue;
3414
3415          /* Fill Logical channel identity */
3416          rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId;
3417
3418          /* Fill Radio Bearer Id and type (DRB/SRB) for this logical channel */
3419          DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3420          if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3421          {
3422             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3423             return RFAILED;
3424          }
3425          rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3426                                                                       covertRbTypeFromIntEnumToRrcEnum(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbType);
3427          switch(rlcBearerList->list.array[idx]->servedRadioBearer->present)
3428          {
3429             case RLC_BearerConfig__servedRadioBearer_PR_srb_Identity:
3430                rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3431                break;
3432             case RLC_BearerConfig__servedRadioBearer_PR_drb_Identity:
3433                rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3434                break;
3435             case RLC_BearerConfig__servedRadioBearer_PR_NOTHING:
3436             default:
3437                break;
3438          }
3439          ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent = true;
3440
3441          rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3442
3443          /* Fill RLC related Configurations for this Radio Bearer */
3444          rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3445          DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3446          if(!rlcBearerList->list.array[idx]->rlc_Config)
3447          {
3448             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3449             return RFAILED;
3450          }
3451          if(BuildRlcConfig(&ueCb->rlcUeCfg.rlcLcCfg[lcIdx], rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3452          {
3453             DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3454             return RFAILED;
3455          }
3456
3457          /* Fill MAC related configurations for this Radio Bearer */
3458          rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3459          DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3460          if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3461          {
3462             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3463             return RFAILED;
3464          }
3465          for(macLcIdx = 0; macLcIdx < ueCb->macUeCfg.numLcs; macLcIdx++)
3466          {
3467             if(ueCb->macUeCfg.lcCfgList[macLcIdx].lcId == ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId)
3468             {
3469                if(BuildMacLCConfig(&ueCb->macUeCfg.lcCfgList[macLcIdx], rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3470                {
3471                   DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3472                   return RFAILED;
3473                }
3474                break;
3475             }
3476          }
3477
3478          idx++;
3479       }
3480    }
3481    return ROK;
3482 }
3483
3484 /*******************************************************************
3485  *
3486  * @brief Build Control resource set to add/modify list
3487  *
3488  * @details
3489  *
3490  *    Function : BuildControlRSetToAddModList
3491  *
3492  *    Functionality: Build Control resource set to add/modify list
3493  *
3494  * @params[in]
3495  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3496  *
3497  * @return ROK     - success
3498  *         RFAILED - failure
3499  *
3500  * ****************************************************************/
3501 uint8_t BuildControlRSetToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList)
3502 {
3503    uint8_t idx;
3504    uint8_t elementCnt;
3505    uint8_t numBytes, bitsUnused;
3506    struct ControlResourceSet *controlRSet;
3507    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3508    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3509
3510    if(pdcchCfg == NULLP)
3511       elementCnt = 1;
3512    else
3513       elementCnt = pdcchCfg->numCRsetToAddMod;
3514
3515    controlRSetList->list.count = elementCnt;
3516    controlRSetList->list.size = elementCnt * sizeof(struct ControlResourceSet *);
3517
3518    controlRSetList->list.array = NULLP;
3519    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3520    if(!controlRSetList->list.array)
3521    {
3522       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3523       return RFAILED;
3524    }
3525
3526    for(idx = 0; idx < elementCnt; idx++)
3527    {
3528       controlRSetList->list.array[idx] = NULLP;
3529       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3530       if(!controlRSetList->list.array[idx])
3531       {
3532          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3533          return RFAILED;
3534       }
3535    }
3536
3537    for(idx = 0; idx < elementCnt; idx++)
3538    {
3539       controlRSet = controlRSetList->list.array[idx];
3540
3541       if(pdcchCfg == NULLP)
3542          controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3543       else
3544          controlRSet->controlResourceSetId = pdcchCfg->cRSetToAddModList[idx].cRSetId;
3545
3546       /* size 6 bytes
3547        * 3 LSBs unsued
3548        * Bit string stored ff0000000000
3549        */
3550       numBytes = 6;
3551       bitsUnused = 3;
3552       controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3553
3554       controlRSet->frequencyDomainResources.buf = NULLP;
3555       DU_ALLOC(controlRSet->frequencyDomainResources.buf, controlRSet->frequencyDomainResources.size);
3556       if(!controlRSet->frequencyDomainResources.buf)
3557       {
3558          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3559          return RFAILED;
3560       }
3561
3562       memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3563
3564       if(pdcchCfg == NULLP)
3565       {
3566          coreset0EndPrb = CORESET0_END_PRB;
3567          coreset1StartPrb = coreset0EndPrb + 6;
3568          coreset1NumPrb = CORESET1_NUM_PRB;
3569          /* calculate the PRBs */
3570          fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3571          memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3572          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3573
3574          controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3575          controlRSet->cce_REG_MappingType.present = ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3576          controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3577       }
3578       else
3579       {
3580          memcpy(controlRSet->frequencyDomainResources.buf, pdcchCfg->cRSetToAddModList[idx].freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
3581          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3582          controlRSet->duration = pdcchCfg->cRSetToAddModList[idx].duration;
3583          controlRSet->cce_REG_MappingType.present = pdcchCfg->cRSetToAddModList[idx].cceRegMappingType;
3584          controlRSet->precoderGranularity = pdcchCfg->cRSetToAddModList[idx].precoderGranularity;
3585       }
3586       controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3587       controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3588       controlRSet->tci_PresentInDCI = NULLP;
3589
3590 #if 0
3591       uint8_t tciStateIdx;
3592
3593       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3594             sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3595       if(!controlRset->tci_StatesPDCCH_ToAddList)
3596       {
3597          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3598          return RFAILED;
3599       }
3600
3601       elementCnt = 1;
3602       controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3603       controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3604       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3605             controlRset->tci_StatesPDCCH_ToAddList->list.size)
3606          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3607          {
3608             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3609             return RFAILED;
3610          }
3611
3612       for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3613       {
3614          DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3615          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3616          {
3617             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3618             return RFAILED;
3619          }
3620       }
3621
3622       tciStateIdx = 0;
3623       /* TODO */
3624       *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3625
3626       DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3627       if(!controlRset->tci_PresentInDCI)
3628       {
3629          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3630          return RFAILED;
3631       }
3632       /* TODO */
3633       *(controlRset->tci_PresentInDCI);
3634 #endif
3635
3636       controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3637       DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3638       if(!controlRSet->pdcch_DMRS_ScramblingID)
3639       {
3640          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3641          return RFAILED;
3642       }
3643       if(pdcchCfg == NULLP)
3644          *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3645       else
3646          *(controlRSet->pdcch_DMRS_ScramblingID) = pdcchCfg->cRSetToAddModList[idx].dmrsScramblingId;
3647    }
3648    return ROK;
3649 } /* End BuildControlRSetToAddModList */
3650
3651 /*******************************************************************
3652  *
3653  * @brief Build search space to add/modify list
3654  *
3655  * @details
3656  *
3657  *    Function : BuildSearchSpcToAddModList
3658  *
3659  *    Functionality: Build search space to add/modify list
3660  *
3661  * @params[in]
3662  * @return ROK     - success
3663  *         RFAILED - failure
3664  *
3665  * ****************************************************************/
3666 uint8_t BuildSearchSpcToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
3667 {
3668    uint8_t idx;
3669    uint8_t numBytes;
3670    uint8_t byteIdx;
3671    uint8_t bitsUnused;
3672    uint8_t elementCnt;
3673    struct SearchSpace *searchSpc;
3674
3675    if(pdcchCfg == NULLP)
3676       elementCnt = 1;
3677    else
3678       elementCnt = pdcchCfg->numSearchSpcToAddMod;
3679
3680    searchSpcList->list.count = elementCnt;
3681    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3682
3683    searchSpcList->list.array = NULLP;
3684    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3685    if(!searchSpcList->list.array)
3686    {
3687       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3688       return RFAILED;
3689    }
3690
3691    for(idx = 0; idx < elementCnt; idx++)
3692    {
3693       searchSpcList->list.array[idx] = NULLP;
3694       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3695       if(!searchSpcList->list.array[idx])
3696       {
3697          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3698          return RFAILED;
3699       }
3700    }
3701
3702    for(idx = 0; idx < elementCnt; idx++)
3703    {
3704       searchSpc = searchSpcList->list.array[idx];
3705
3706       if(pdcchCfg == NULLP)
3707          searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3708       else
3709          searchSpc->searchSpaceId = pdcchCfg->searchSpcToAddModList[idx].searchSpaceId;
3710
3711       searchSpc->controlResourceSetId = NULLP;
3712       DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3713       if(!searchSpc->controlResourceSetId)
3714       {
3715          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3716          return RFAILED;
3717       }
3718       if(pdcchCfg == NULLP)
3719          *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3720       else
3721          *(searchSpc->controlResourceSetId) = pdcchCfg->searchSpcToAddModList[idx].cRSetId;
3722
3723       searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3724       DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3725       if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3726       {
3727          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3728          return RFAILED;
3729       }
3730       if(pdcchCfg == NULLP)
3731          searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3732       else
3733          searchSpc->monitoringSlotPeriodicityAndOffset->present = pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset;
3734
3735       searchSpc->duration = NULLP;
3736       searchSpc->monitoringSymbolsWithinSlot = NULLP;
3737       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3738       if(!searchSpc->monitoringSymbolsWithinSlot)
3739       {
3740          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3741          return RFAILED;
3742       }
3743
3744       /* Values taken from reference logs :
3745        * size 2 bytes
3746        * 2 LSBs unsued
3747        * Bit string stores 8000
3748        */
3749       numBytes = 2;
3750       bitsUnused = 2;
3751       searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3752       searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3753       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
3754       if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3755       {
3756          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3757          return RFAILED;
3758       }
3759       if(pdcchCfg == NULLP)
3760       {
3761          byteIdx = 0;
3762          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3763          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3764       }
3765       else
3766          memcpy(searchSpc->monitoringSymbolsWithinSlot->buf, pdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot, numBytes);
3767       searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3768
3769       searchSpc->nrofCandidates = NULLP;
3770       DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3771       if(!searchSpc->nrofCandidates)
3772       {
3773          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3774          return RFAILED;
3775       }
3776
3777       if(pdcchCfg == NULLP)
3778       {
3779          searchSpc->nrofCandidates->aggregationLevel1 = PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3780          searchSpc->nrofCandidates->aggregationLevel2 = PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3781          searchSpc->nrofCandidates->aggregationLevel4 = PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3782          searchSpc->nrofCandidates->aggregationLevel8 = PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3783          searchSpc->nrofCandidates->aggregationLevel16 = PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3784       }
3785       else
3786       {
3787          searchSpc->nrofCandidates->aggregationLevel1 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1;
3788          searchSpc->nrofCandidates->aggregationLevel2 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2;
3789          searchSpc->nrofCandidates->aggregationLevel4 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4;
3790          searchSpc->nrofCandidates->aggregationLevel8 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8;
3791          searchSpc->nrofCandidates->aggregationLevel16 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16;
3792       }
3793
3794       searchSpc->searchSpaceType = NULLP;
3795       DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3796       if(!searchSpc->searchSpaceType)
3797       {
3798          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3799          return RFAILED;
3800       }
3801       if(pdcchCfg == NULLP)
3802          searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3803       else
3804          searchSpc->searchSpaceType->present = pdcchCfg->searchSpcToAddModList[idx].searchSpaceType;
3805
3806       searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3807       DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3808       if(!searchSpc->searchSpaceType->choice.ue_Specific)
3809       {
3810          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3811          return RFAILED;
3812       }
3813       if(pdcchCfg == NULLP)
3814          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3815       else
3816          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = pdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat;
3817    }
3818    return ROK;
3819 }/* End BuildSearchSpcToAddModList */
3820
3821 /*******************************************************************
3822  *
3823  * @brief Builds BWP DL dedicated PDCCH config
3824  *
3825  * @details
3826  *
3827  *    Function : BuildBWPDlDedPdcchCfg
3828  *
3829  *    Functionality: Builds BWP DL dedicated PDCCH config
3830  *
3831  * @params[in] struct PDCCH_Config *pdcchCfg
3832  *
3833  * @return ROK     - success
3834  *         RFAILED - failure
3835  *
3836  * ****************************************************************/
3837 uint8_t BuildBWPDlDedPdcchCfg(PdcchConfig *pdcchCfgDb, struct PDCCH_Config *pdcchCfg)
3838 {
3839    pdcchCfg->controlResourceSetToAddModList = NULLP;
3840    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3841    if(!pdcchCfg->controlResourceSetToAddModList)
3842    {
3843       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3844       return RFAILED;
3845    }
3846
3847    if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
3848    {
3849       DU_LOG("\nERROR  --> F1AP : Failed in BuildControlRSetToAddModList()");
3850       return RFAILED;
3851    }
3852
3853    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3854
3855    pdcchCfg->searchSpacesToAddModList = NULLP;
3856    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3857    if(!pdcchCfg->searchSpacesToAddModList)
3858    {
3859       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3860       return RFAILED;
3861    }
3862
3863    if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
3864    {
3865       DU_LOG("\nERROR  --> F1AP : Failed in BuildSearchSpcToAddModList()");
3866       return RFAILED;
3867    }
3868
3869    pdcchCfg->searchSpacesToReleaseList = NULLP;
3870    pdcchCfg->downlinkPreemption = NULLP;
3871    pdcchCfg->tpc_PUSCH = NULLP;
3872    pdcchCfg->tpc_PUCCH = NULLP;
3873    pdcchCfg->tpc_SRS = NULLP;
3874
3875    return ROK;
3876 }
3877
3878 /*******************************************************************
3879  *
3880  * @brief Builds DMRS DL PDSCH Mapping type A
3881  *
3882  * @details
3883  *
3884  *    Function : BuildDMRSDLPdschMapTypeA
3885  *
3886  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3887  *
3888  * @params[in]
3889  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3890  * @return ROK     - success
3891  *         RFAILED - failure
3892  *
3893  * ****************************************************************/
3894 uint8_t BuildDMRSDLPdschMapTypeA(PdschConfig *pdschCfg, struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg)
3895 {
3896    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3897    dmrsDlCfg->choice.setup = NULLP;
3898    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3899    if(!dmrsDlCfg->choice.setup)
3900    {
3901       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3902       return RFAILED;
3903    }
3904
3905    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3906    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3907    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3908    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3909    {
3910       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3911       return RFAILED;
3912    }
3913    if(pdschCfg == NULLP)
3914       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3915    else
3916       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = pdschCfg->dmrsDlCfgForPdschMapTypeA.addPos;
3917
3918    dmrsDlCfg->choice.setup->maxLength = NULLP;
3919    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3920    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3921    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3922
3923    return ROK;
3924 }
3925
3926 /*******************************************************************
3927  *
3928  * @brief Builds TCI states to add/modify list
3929  *
3930  * @details
3931  *
3932  *    Function : BuildTCIStatesToAddModList
3933  *
3934  *    Functionality:Builds TCI states to add/modify list
3935  *
3936  * @params[in]
3937  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3938  *
3939  * @return ROK     - success
3940  *         RFAILED - failure
3941  *
3942  * ****************************************************************/
3943 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3944 {
3945    return ROK;
3946 }
3947
3948 /*******************************************************************
3949  *
3950  * @brief Builds PDSCH time domain allocation list
3951  *
3952  * @details
3953  *
3954  *    Function : BuildPdschTimeDomAllocList
3955  *
3956  *    Functionality: Builds PDSCH time domain allocation list
3957  *
3958  * @params[in]
3959  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3960  *
3961  * @return ROK     - success
3962  *         RFAILED - failure
3963  *
3964  * ****************************************************************/
3965 uint8_t BuildPdschTimeDomAllocList(PdschConfig *pdschCfg, struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
3966 {
3967    uint8_t idx;
3968    uint8_t elementCnt;
3969    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3970
3971    timeDomAllocList->present = PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3972
3973    timeDomAllocList->choice.setup = NULLP;
3974    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3975    if(!timeDomAllocList->choice.setup)
3976    {
3977       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3978       return RFAILED;
3979    }
3980
3981 if(pdschCfg == NULLP)
3982    elementCnt = 2;
3983 else
3984 elementCnt = pdschCfg->numTimeDomRsrcAlloc;
3985    timeDomAllocList->choice.setup->list.count = elementCnt;
3986    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3987
3988    timeDomAllocList->choice.setup->list.array = NULLP;
3989    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
3990    if(!timeDomAllocList->choice.setup->list.array)
3991    {
3992       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3993       return RFAILED;
3994    }
3995
3996    for(idx = 0; idx < elementCnt; idx++)
3997    {
3998       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3999       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
4000             sizeof(struct PDSCH_TimeDomainResourceAllocation));
4001       if(!timeDomAllocList->choice.setup->list.array[idx])
4002       {
4003          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4004          return RFAILED;
4005       }
4006    }
4007
4008    if(pdschCfg == NULLP)
4009    {
4010       idx = 0;
4011       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4012       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4013       if(!timeDomAlloc->k0)
4014       {
4015          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4016          return RFAILED;
4017       }
4018       *(timeDomAlloc->k0) = 0;
4019       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4020       timeDomAlloc->startSymbolAndLength = \
4021                                            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4022
4023       idx++;
4024       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4025       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4026       if(!timeDomAlloc->k0)
4027       {
4028          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4029          return RFAILED;
4030       }
4031       *(timeDomAlloc->k0) = 1;
4032       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4033       timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4034    }
4035    else
4036    {
4037       for(idx = 0; idx < elementCnt; idx++)
4038       {
4039          timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4040          DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4041          if(!timeDomAlloc->k0)
4042          {
4043             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4044             return RFAILED;
4045          }
4046          if(pdschCfg->timeDomRsrcAllociList[idx].k0)
4047             *(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
4048          timeDomAlloc->mappingType = pdschCfg->timeDomRsrcAllociList[idx].mappingType;
4049          timeDomAlloc->startSymbolAndLength = pdschCfg->timeDomRsrcAllociList[idx].startSymbolAndLength;
4050       }
4051    }
4052
4053    return ROK;
4054 }
4055
4056 /*******************************************************************
4057  *
4058  * @brief Builds PDSCH PRB Bundling type
4059  *
4060  * @details
4061  *
4062  *    Function : BuildPdschPrbBundlingType
4063  *
4064  *    Functionality: Builds PDSCH PRB Bundling type
4065  *
4066  * @params[in]
4067  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4068  *
4069  * @return ROK     - success
4070  *         RFAILED - failure
4071  *
4072  * ****************************************************************/
4073 uint8_t BuildPdschPrbBundlingType(PdschConfig *pdschCfg, struct PDSCH_Config__prb_BundlingType *prbBndlType)
4074 {
4075    if(pdschCfg == NULLP)
4076       prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4077    else
4078       prbBndlType->present = pdschCfg->bundlingType;
4079
4080    prbBndlType->choice.staticBundling = NULLP;
4081    DU_ALLOC(prbBndlType->choice.staticBundling, \
4082          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4083    if(!prbBndlType->choice.staticBundling)
4084    {
4085       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4086       return RFAILED;
4087    }
4088    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4089
4090    return ROK;
4091 }
4092
4093 /*******************************************************************
4094  *
4095  * @brief Builds BWP DL dedicated PDSCH config
4096  *
4097  * @details
4098  *
4099  *    Function : BuildBWPDlDedPdschCfg
4100  *
4101  *    Functionality: Builds BWP DL dedicated PDSCH config
4102  *
4103  * @params[in] struct PDSCH_Config *pdschCfg
4104  *
4105  * @return ROK     - success
4106  *         RFAILED - failure
4107  *
4108  * ****************************************************************/
4109 uint8_t BuildBWPDlDedPdschCfg(PdschConfig *pdschCfgDb, struct PDSCH_Config *pdschCfg)
4110 {
4111    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4112
4113    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4114    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4115    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4116    {
4117       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4118       return RFAILED;
4119    }
4120
4121    if(BuildDMRSDLPdschMapTypeA(pdschCfgDb, pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4122    {
4123       return RFAILED;
4124    }
4125
4126    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4127    pdschCfg->tci_StatesToAddModList = NULLP;
4128    pdschCfg->tci_StatesToReleaseList = NULLP;
4129    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4130 #if 0
4131    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4132    if(!pdschCfg->tci_StatesToAddModList)
4133    {
4134       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4135       return RFAILED;
4136    }
4137    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4138    {
4139       return RFAILED;
4140    }
4141 #endif
4142
4143 if(pdschCfgDb == NULLP)
4144    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4145 else
4146 pdschCfg->resourceAllocation = pdschCfgDb->resourceAllocType;
4147
4148    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4149    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4150    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4151    {
4152       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4153       return RFAILED;
4154    }
4155    if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4156    {
4157       return RFAILED;
4158    }
4159
4160    pdschCfg->pdsch_AggregationFactor = NULLP;
4161    pdschCfg->rateMatchPatternToAddModList = NULLP;
4162    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4163    pdschCfg->rateMatchPatternGroup1 = NULLP;
4164    pdschCfg->rateMatchPatternGroup2 = NULLP;
4165    if(pdschCfgDb == NULLP)
4166       pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4167    else
4168       pdschCfg->rbg_Size = pdschCfgDb->rbgSize;
4169    pdschCfg->mcs_Table = NULLP;
4170
4171    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4172    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4173    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4174    {
4175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4176       return RFAILED;
4177    }
4178    if(pdschCfgDb == NULLP)
4179       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4180    else
4181       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = pdschCfgDb->numCodeWordsSchByDci;
4182
4183    if(BuildPdschPrbBundlingType(pdschCfgDb, &pdschCfg->prb_BundlingType) != ROK)
4184    {
4185       return RFAILED;
4186    }
4187
4188    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4189    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4190    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4191    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4192    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4193    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4194    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4195
4196    return ROK;
4197 }
4198
4199 /*******************************************************************
4200  *
4201  * @brief Builds intitial DL BWP
4202  * @details
4203  *
4204  *    Function : BuildInitialDlBWP
4205  *
4206  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4207  *
4208  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4209  *
4210  * @return ROK     - success
4211  *         RFAILED - failure
4212  *
4213  * ****************************************************************/
4214 uint8_t BuildInitialDlBWP(InitialDlBwp *initiDlBwp, BWP_DownlinkDedicated_t *dlBwp)
4215 {
4216    PdcchConfig *pdcchCfg = NULLP;
4217    PdschConfig *pdschCfg = NULLP;
4218
4219    if(initiDlBwp)
4220    {
4221       if(initiDlBwp->pdcchPresent)
4222          pdcchCfg = &initiDlBwp->pdcchCfg;
4223       if(initiDlBwp->pdschPresent)
4224          pdschCfg = &initiDlBwp->pdschCfg;
4225    }
4226
4227    dlBwp->pdcch_Config = NULLP;
4228    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4229    if(!dlBwp->pdcch_Config)
4230    {
4231       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4232       return RFAILED;
4233    }
4234    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4235
4236    dlBwp->pdcch_Config->choice.setup = NULLP;
4237    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4238    if(!dlBwp->pdcch_Config->choice.setup)
4239    {
4240       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4241       return RFAILED;
4242    }
4243    if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
4244    {
4245       return RFAILED;
4246    }
4247
4248    dlBwp->pdsch_Config = NULLP;
4249    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4250    if(!dlBwp->pdsch_Config)
4251    {
4252       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4253       return RFAILED;
4254    }
4255    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4256
4257    dlBwp->pdsch_Config->choice.setup = NULLP;
4258    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4259    if(!dlBwp->pdsch_Config->choice.setup)
4260    {
4261       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4262       return RFAILED;
4263    }
4264
4265    if(BuildBWPDlDedPdschCfg(pdschCfg, dlBwp->pdsch_Config->choice.setup) != ROK)
4266    {
4267       return RFAILED;
4268    }
4269
4270    dlBwp->sps_Config = NULLP;
4271    dlBwp->radioLinkMonitoringConfig = NULLP;
4272    return ROK;
4273 }
4274
4275 /*******************************************************************
4276  *
4277  * @brief Builds DMRS UL Pusch Mapping type A
4278  *
4279  * @details
4280  *
4281  *    Function : BuildDMRSULPuschMapTypeA
4282  *
4283  *    Functionality: Builds DMRS UL Pusch Mapping type A
4284  *
4285  * @params[in]
4286  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4287  * @return ROK     - success
4288  *         RFAILED - failure
4289  *
4290  * ****************************************************************/
4291 uint8_t BuildDMRSULPuschMapTypeA(DmrsUlCfg *ulDmrsCfgDb, struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg)
4292 {
4293    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4294    dmrsUlCfg->choice.setup= NULLP;
4295    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4296    if(!dmrsUlCfg->choice.setup)
4297    {
4298       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4299       return RFAILED;
4300    }
4301
4302    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4303    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4304    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4305    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4306    {
4307       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4308       return RFAILED;
4309    }
4310    if(ulDmrsCfgDb == NULLP)
4311       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4312    else
4313       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = ulDmrsCfgDb->addPos;
4314
4315    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4316    dmrsUlCfg->choice.setup->maxLength = NULLP;
4317    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4318    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4319    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4320    {
4321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4322       return RFAILED;
4323    }
4324
4325    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4326    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4327          sizeof(long));
4328    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4329    {
4330       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4331       return RFAILED;
4332    }
4333    if(ulDmrsCfgDb == NULLP)
4334       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4335    else
4336       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = ulDmrsCfgDb->transPrecodDisabled.scramblingId0;
4337
4338    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4339    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4340    return ROK;
4341 }
4342
4343 /*******************************************************************
4344  *
4345  * @brief Build PUSCH time domain allocation list
4346  *
4347  * @details
4348  *
4349  *    Function : BuildPuschTimeDomAllocList
4350  *
4351  *    Functionality: Build PUSCH time domain allocation list
4352  *
4353  * @params[in]
4354  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4355  *
4356  * @return ROK     - success
4357  *         RFAILED - failure
4358  *
4359  * ****************************************************************/
4360 uint8_t BuildPuschTimeDomAllocList(PuschCfg *puschCfgDb, struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList)
4361 {
4362    uint8_t idx;
4363    uint8_t elementCnt;
4364    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4365
4366    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4367    timeDomAllocList->choice.setup = NULLP;
4368    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4369    if(!timeDomAllocList->choice.setup)
4370    {
4371       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4372       return RFAILED;
4373    }
4374
4375    if(puschCfgDb == NULLP)
4376       elementCnt = 2;
4377    else
4378       elementCnt = puschCfgDb->numTimeDomRsrcAlloc;
4379
4380    timeDomAllocList->choice.setup->list.count = elementCnt;
4381    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4382    timeDomAllocList->choice.setup->list.array = NULLP;
4383    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4384    if(!timeDomAllocList->choice.setup->list.array)
4385    {
4386       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4387       return RFAILED;
4388    }
4389
4390    for(idx = 0; idx < elementCnt; idx++)
4391    {
4392       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4393       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
4394       if(!timeDomAllocList->choice.setup->list.array[idx])
4395       {
4396          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4397          return RFAILED;
4398       }
4399    }
4400
4401    for(idx = 0; idx < elementCnt; idx++)
4402    {
4403       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4404       DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4405       if(!timeDomAlloc->k2)
4406       {
4407          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4408          return RFAILED;
4409       }
4410       if(puschCfgDb == NULLP)
4411       {
4412          if(idx == 0)
4413             *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4414          else if(idx == 1)
4415             *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4416
4417          timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4418          timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4419       }
4420       else
4421       {
4422          *(timeDomAlloc->k2) = puschCfgDb->timeDomRsrcAllocList[idx].k2;
4423          timeDomAlloc->mappingType = puschCfgDb->timeDomRsrcAllocList[idx].mappingType;
4424          timeDomAlloc->startSymbolAndLength = puschCfgDb->timeDomRsrcAllocList[idx].startSymbolAndLength;
4425       }
4426    }
4427
4428    return ROK;
4429 }
4430
4431 /*******************************************************************
4432  *
4433  * @brief Builds BWP UL dedicated PUSCH Config
4434  *
4435  * @details
4436  *
4437  *    Function : BuildBWPUlDedPuschCfg
4438  *
4439  *    Functionality:
4440  *      Builds BWP UL dedicated PUSCH Config
4441  *
4442  * @params[in] : PUSCH_Config_t *puschCfg
4443  *
4444  * @return ROK     - success
4445  *         RFAILED - failure
4446  *
4447  * ****************************************************************/
4448 uint8_t BuildBWPUlDedPuschCfg(PuschCfg *puschCfgDb, PUSCH_Config_t *puschCfg)
4449 {
4450    DmrsUlCfg *ulDmrsCfg = NULLP;
4451
4452    if(puschCfgDb)
4453       ulDmrsCfg = &puschCfgDb->dmrsUlCfgForPuschMapTypeA;
4454
4455    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4456    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4457    if(!puschCfg->dataScramblingIdentityPUSCH)
4458    {
4459       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4460       return RFAILED;
4461    }
4462    if(puschCfgDb == NULLP)
4463       *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4464    else
4465       *(puschCfg->dataScramblingIdentityPUSCH) = puschCfgDb->dataScramblingId;
4466
4467    puschCfg->txConfig = NULLP;
4468    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4469    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4470    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4471    {
4472       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4473       return RFAILED;
4474    }
4475
4476    if(BuildDMRSULPuschMapTypeA(ulDmrsCfg, puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4477    {
4478       return RFAILED;
4479    }
4480
4481    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4482    puschCfg->pusch_PowerControl = NULLP;
4483    puschCfg->frequencyHopping = NULLP;
4484    puschCfg->frequencyHoppingOffsetLists = NULLP;
4485
4486    if(puschCfgDb == NULLP)
4487       puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4488    else
4489       puschCfg->resourceAllocation = puschCfgDb->resourceAllocType;
4490
4491    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4492    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4493    if(!puschCfg->pusch_TimeDomainAllocationList)
4494    {
4495       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4496       return RFAILED;
4497    }
4498
4499    if(BuildPuschTimeDomAllocList(puschCfgDb, puschCfg->pusch_TimeDomainAllocationList) != ROK)
4500    {
4501       return RFAILED;
4502    }
4503
4504    puschCfg->pusch_AggregationFactor = NULLP;
4505    puschCfg->mcs_Table = NULLP;
4506    puschCfg->mcs_TableTransformPrecoder = NULLP;
4507    puschCfg->transformPrecoder = NULLP;
4508    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4509    if(!puschCfg->transformPrecoder)
4510    {
4511       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4512       return RFAILED;
4513    }
4514    if(puschCfgDb == NULLP)
4515       *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4516    else
4517       *(puschCfg->transformPrecoder) = puschCfgDb->transformPrecoder;
4518
4519    puschCfg->codebookSubset = NULLP;
4520    puschCfg->maxRank = NULLP;
4521    puschCfg->rbg_Size = NULLP;
4522    puschCfg->uci_OnPUSCH = NULLP;
4523    puschCfg->tp_pi2BPSK = NULLP;
4524
4525    return ROK;
4526 }
4527
4528 /*******************************************************************
4529  *
4530  * @brief Builds PUCCH resource set add/modify list
4531  *
4532  * @details
4533  *
4534  *    Function : BuildPucchRsrcSetAddModList
4535  *
4536  *    Functionality:
4537  *      Builds PUCCH resource set add/modify list
4538  *
4539  * @params[in] : PucchResrcSetCfg *rsrcSetCfgDb
4540  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4541  *
4542  * @return ROK     - success
4543  *         RFAILED - failure
4544  *
4545  * ****************************************************************/
4546 uint8_t BuildPucchRsrcSetAddModList(PucchResrcSetCfg *rsrcSetCfgDb, \
4547    struct PUCCH_Config__resourceSetToAddModList *resourceSetToAddModList)
4548 {
4549    uint8_t elementCnt = 0, rsrcSetIdx = 0, rsrcIdx = 0;
4550    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4551
4552    if(rsrcSetCfgDb == NULLP)
4553       elementCnt = 1;
4554    else
4555       elementCnt = rsrcSetCfgDb->resrcSetToAddModListCount;
4556
4557    resourceSetToAddModList->list.count = elementCnt;
4558    resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4559    DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
4560    if(resourceSetToAddModList->list.array == NULLP)
4561    {
4562       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4563       return RFAILED;
4564    }
4565    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4566    {
4567       DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4568       if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4569       {
4570          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4571          return RFAILED;
4572       }
4573    }
4574
4575    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4576    {
4577       rsrcSet = resourceSetToAddModList->list.array[rsrcSetIdx];
4578
4579       /* Resource set Id */
4580       if(rsrcSetCfgDb == NULLP)
4581          rsrcSet->pucch_ResourceSetId = 1;
4582       else
4583          rsrcSet->pucch_ResourceSetId = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcSetId;
4584
4585       /* Resource list of a resource set */
4586       if(rsrcSetCfgDb == NULLP)
4587          elementCnt = 1;
4588       else
4589          elementCnt = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcListCount;
4590       rsrcSet->resourceList.list.count = elementCnt;
4591       rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4592       DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4593       if(rsrcSet->resourceList.list.array == 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          DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4602          if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4603          {
4604             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4605             return RFAILED;
4606          }
4607       }
4608       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4609       {
4610          if(rsrcSetCfgDb == NULLP)
4611             *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4612          else
4613             *(rsrcSet->resourceList.list.array[rsrcIdx]) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcList[rsrcIdx];
4614       }
4615
4616       /* Max payload size (minus 1) in a Resource set */
4617       rsrcSet->maxPayloadMinus1 = NULLP;
4618       if(rsrcSetCfgDb && rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize)
4619       {
4620          DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
4621          if(rsrcSet->maxPayloadMinus1 == NULLP)
4622          {
4623             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4624             return RFAILED;
4625          }
4626          *(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
4627       }
4628    }
4629    return ROK;
4630 }
4631
4632 /*******************************************************************
4633  *
4634  * @brief Builds PUCCH resource add/modify list
4635  *
4636  * @details
4637  *
4638  *    Function : BuildPucchRsrcAdddModList
4639  *
4640  *    Functionality:
4641  *      Builds PUCCH resource add/modify list
4642  *
4643  * @params[in] : PucchResrcCfg *rsrcSetCfgDb
4644  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4645  *
4646  * @return ROK     - success
4647  *         RFAILED - failure
4648  *
4649  * ****************************************************************/
4650 uint8_t BuildPucchRsrcAddModList(PucchResrcCfg *rsrcCfgDb, struct PUCCH_Config__resourceToAddModList  *resourceToAddModList)
4651 {
4652    uint8_t elementCnt = 0, rsrcIdx = 0;
4653    PUCCH_Resource_t *rsrc = NULLP;
4654
4655    if(rsrcCfgDb == NULLP)
4656       elementCnt = 1;
4657    else
4658       elementCnt = rsrcCfgDb->resrcToAddModListCount;
4659    resourceToAddModList->list.count = elementCnt;
4660    resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4661    DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
4662    if(resourceToAddModList->list.array == NULLP)
4663    {
4664       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4665       return RFAILED;
4666    }
4667    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4668    {
4669       DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4670       if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
4671       {
4672          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4673          return RFAILED;
4674       }
4675    }
4676
4677    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4678    {
4679       rsrc = resourceToAddModList->list.array[rsrcIdx];
4680
4681       if(rsrcCfgDb == NULLP)
4682       {
4683          rsrc->pucch_ResourceId = 1;
4684          rsrc->startingPRB = 0;
4685          rsrc->format.present = PUCCH_Resource__format_PR_format1;
4686          DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4687          if(rsrc->format.choice.format1 == NULLP)
4688          {
4689             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4690             return RFAILED;
4691          }
4692          rsrc->format.choice.format1->initialCyclicShift = 0;
4693          rsrc->format.choice.format1->nrofSymbols = 4;
4694          rsrc->format.choice.format1->startingSymbolIndex = 0;
4695          rsrc->format.choice.format1->timeDomainOCC = 0;
4696       }
4697       else
4698       {
4699          rsrc->pucch_ResourceId = rsrcCfgDb->resrcToAddModList[rsrcIdx].resrcId;
4700          rsrc->startingPRB = rsrcCfgDb->resrcToAddModList[rsrcIdx].startPrb;
4701          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop)
4702          {
4703             DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
4704             if(rsrc->intraSlotFrequencyHopping == NULLP)
4705             {
4706                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4707                return RFAILED;
4708             }
4709             *(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
4710          }
4711          else
4712             rsrc->intraSlotFrequencyHopping = NULLP;
4713
4714          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop)
4715          {
4716             DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
4717             if(rsrc->secondHopPRB == NULLP)
4718             {
4719                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4720                return RFAILED;
4721             }
4722             *(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
4723          }
4724          else
4725             rsrc->secondHopPRB = NULLP;
4726          rsrc->format.present = covertPucchFormatIntEnumToRrcEnum(rsrcCfgDb->resrcToAddModList[rsrcIdx].pucchFormat);
4727
4728          switch(rsrc->format.present)
4729          {
4730             case PUCCH_Resource__format_PR_NOTHING:
4731                break;
4732             case PUCCH_Resource__format_PR_format0:
4733                {
4734                   DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
4735                   if(rsrc->format.choice.format0 == NULLP)
4736                   {
4737                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4738                      return RFAILED;
4739                   }
4740                   rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
4741                   rsrc->format.choice.format0->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->numSymbols;
4742                   rsrc->format.choice.format0->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->startSymbolIdx;
4743                   break;
4744                }
4745
4746             case PUCCH_Resource__format_PR_format1:
4747                {
4748                   DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4749                   if(rsrc->format.choice.format1 == NULLP)
4750                   {
4751                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4752                      return RFAILED;
4753                   }
4754                   rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
4755                   rsrc->format.choice.format1->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->numSymbols;
4756                   rsrc->format.choice.format1->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->startSymbolIdx;
4757                   rsrc->format.choice.format1->timeDomainOCC = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->timeDomOCC;
4758                   break;
4759                }
4760
4761             case PUCCH_Resource__format_PR_format2:
4762                {
4763                   DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
4764                   if(rsrc->format.choice.format2 == NULLP)
4765                   {
4766                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4767                      return RFAILED;
4768                   }
4769                   rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
4770                   rsrc->format.choice.format2->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numSymbols;
4771                   rsrc->format.choice.format2->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->startSymbolIdx;
4772                   break;
4773                }
4774
4775             case PUCCH_Resource__format_PR_format3:
4776                {
4777                   DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
4778                   if(rsrc->format.choice.format3 == NULLP)
4779                   {
4780                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4781                      return RFAILED;
4782                   }
4783                   rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
4784                   rsrc->format.choice.format3->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numSymbols;
4785                   rsrc->format.choice.format3->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->startSymbolIdx;
4786                   break;
4787                }
4788
4789             case PUCCH_Resource__format_PR_format4:
4790                {
4791                   DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
4792                   if(rsrc->format.choice.format4 == NULLP)
4793                   {
4794                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4795                      return RFAILED;
4796                   }
4797                   rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
4798                   rsrc->format.choice.format4->occ_Length = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occLen;
4799                   rsrc->format.choice.format4->occ_Index = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occIdx;
4800                   rsrc->format.choice.format4->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->startSymbolIdx;
4801                   break;
4802                }
4803          }
4804       }
4805    }
4806    return ROK;
4807 }
4808
4809 /*******************************************************************
4810  *
4811  * @brief Builds PUCCH format  config
4812  *
4813  * @details
4814  *
4815  *    Function : BuildPucchFormat
4816  *
4817  *    Functionality: Builds PUCCH format  config
4818  *
4819  * @params[in] : PucchFormatCfg *formatDb
4820  *               PUCCH_FormatConfig_t *format
4821  *
4822  * @return ROK     - success
4823  *         RFAILED - failure
4824  *
4825  * ****************************************************************/
4826 uint8_t BuildPucchFormat(PucchFormatCfg *formatDb, PUCCH_FormatConfig_t *format)
4827 {
4828    /* Inter Slot Fequency hopping */
4829    format->interslotFrequencyHopping = NULLP;
4830    if((formatDb != NULLP) && (formatDb->interSlotFreqHop == true))
4831    {
4832       DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
4833       if(format->interslotFrequencyHopping)
4834       {
4835          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4836          return RFAILED;
4837       }
4838       *(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
4839    }
4840
4841    /* Additional DMRS */
4842    format->additionalDMRS = NULLP;
4843    if((formatDb != NULLP) && (formatDb->addDmrs == true))
4844    {
4845       DU_ALLOC(format->additionalDMRS, sizeof(long));
4846       if(format->additionalDMRS)
4847       {
4848          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4849          return RFAILED;
4850       }
4851       *(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
4852    }
4853
4854     /* Maximum code rate */
4855    format->maxCodeRate = NULLP;
4856    if((formatDb != NULLP) && (formatDb->maxCodeRate != 0))
4857    {
4858       DU_ALLOC(format->maxCodeRate, sizeof(long));
4859       if(format->maxCodeRate)
4860       {
4861          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4862          return RFAILED;
4863       }
4864       *(format->maxCodeRate) = formatDb->maxCodeRate;
4865    }
4866
4867    /* Number of slots */
4868    format->nrofSlots = NULLP;
4869    if((formatDb == NULLP) || ((formatDb != NULLP) && (formatDb->numSlots != 0)))
4870    {
4871       DU_ALLOC(format->nrofSlots, sizeof(long));
4872       if(format->nrofSlots == NULLP)
4873       {
4874          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4875          return RFAILED;
4876       }
4877       if(formatDb == NULLP)
4878          *(format->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4879       else
4880          *(format->nrofSlots) = formatDb->numSlots;
4881    }
4882
4883    /* Pi2BPSK*/
4884    format->pi2BPSK = NULLP;
4885    if((formatDb != NULLP) && (formatDb->pi2BPSK == true))
4886    {
4887       DU_ALLOC(format->pi2BPSK, sizeof(long));
4888       if(format->pi2BPSK)
4889       {
4890          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4891          return RFAILED;
4892       }
4893       *(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
4894    }
4895
4896    /* Simultaneous HARQ ACK and CSI */
4897    format->simultaneousHARQ_ACK_CSI = NULLP;
4898    if((formatDb != NULLP) && (formatDb->harqAckCSI == true))
4899    {
4900       DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
4901       if(format->simultaneousHARQ_ACK_CSI)
4902       {
4903          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4904          return RFAILED;
4905       }
4906       *(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
4907    }
4908
4909    return ROK;
4910 }
4911
4912
4913 /*******************************************************************
4914  *
4915  * @brief Builds PUCCH scheduling request list
4916  *
4917  * @details
4918  *
4919  *    Function : BuildPucchSchReqAddModList
4920  *
4921  *    Functionality:
4922  *      Builds PUCCH scheduling request list
4923  *
4924  * @params[in] : PucchSchedReqCfg *schReqDb
4925  *               struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList
4926  *
4927  * @return ROK     - success
4928  *         RFAILED - failure
4929  *
4930  * ****************************************************************/
4931 uint8_t BuildPucchSchReqAddModList(PucchSchedReqCfg *schReqDb, \
4932    struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList)
4933 {
4934    uint8_t elementCnt = 0, schReqIdx = 0;
4935    SchedulingRequestResourceConfig_t *schReqRsrc;
4936
4937    elementCnt = schReqDb->schedAddModListCount;
4938    schReqRsrcToAddModList->list.count = elementCnt;
4939    schReqRsrcToAddModList->list.size = elementCnt *sizeof(struct SchedulingRequestResourceConfig *);
4940
4941    schReqRsrcToAddModList->list.array = NULLP;
4942    DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
4943    if(schReqRsrcToAddModList->list.array == NULLP)
4944    {
4945       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4946       return RFAILED;
4947    }
4948
4949    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4950    {
4951       DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
4952       if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
4953       {
4954          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4955          return RFAILED;
4956       }
4957    }
4958
4959    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4960    {
4961       schReqRsrc = schReqRsrcToAddModList->list.array[schReqIdx];
4962       schReqRsrc->schedulingRequestResourceId = schReqDb->schedAddModList[schReqIdx].resrcId;
4963       schReqRsrc->schedulingRequestID = schReqDb->schedAddModList[schReqIdx].requestId;
4964
4965       if(schReqDb->schedAddModList[schReqIdx].periodicity)
4966       {
4967          schReqRsrc->periodicityAndOffset = NULLP;
4968          DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
4969          if(schReqRsrc->periodicityAndOffset == NULLP)
4970          {
4971             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4972             return RFAILED;
4973          }
4974
4975          schReqRsrc->periodicityAndOffset->present = schReqDb->schedAddModList[schReqIdx].periodicity;
4976          switch(schReqRsrc->periodicityAndOffset->present)
4977          {
4978             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_NOTHING:
4979                break;
4980             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
4981                schReqRsrc->periodicityAndOffset->choice.sym2 = schReqDb->schedAddModList[schReqIdx].offset;
4982                break;
4983             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
4984                schReqRsrc->periodicityAndOffset->choice.sym6or7 = schReqDb->schedAddModList[schReqIdx].offset;
4985                break;
4986             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
4987                schReqRsrc->periodicityAndOffset->choice.sl1 = schReqDb->schedAddModList[schReqIdx].offset;
4988                break;
4989             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
4990                schReqRsrc->periodicityAndOffset->choice.sl2 = schReqDb->schedAddModList[schReqIdx].offset;
4991                break;
4992             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
4993                schReqRsrc->periodicityAndOffset->choice.sl4 = schReqDb->schedAddModList[schReqIdx].offset;
4994                break;
4995             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
4996                schReqRsrc->periodicityAndOffset->choice.sl5 = schReqDb->schedAddModList[schReqIdx].offset;
4997                break;
4998             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
4999                schReqRsrc->periodicityAndOffset->choice.sl8 = schReqDb->schedAddModList[schReqIdx].offset;
5000                break;
5001             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
5002                schReqRsrc->periodicityAndOffset->choice.sl10 = schReqDb->schedAddModList[schReqIdx].offset;
5003                break;
5004             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
5005                schReqRsrc->periodicityAndOffset->choice.sl16 = schReqDb->schedAddModList[schReqIdx].offset;
5006                break;
5007             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
5008                schReqRsrc->periodicityAndOffset->choice.sl20 = schReqDb->schedAddModList[schReqIdx].offset;
5009                break;
5010             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
5011                schReqRsrc->periodicityAndOffset->choice.sl40 = schReqDb->schedAddModList[schReqIdx].offset;
5012                break;
5013             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
5014                schReqRsrc->periodicityAndOffset->choice.sl80 = schReqDb->schedAddModList[schReqIdx].offset;
5015                break;
5016             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
5017                schReqRsrc->periodicityAndOffset->choice.sl160 = schReqDb->schedAddModList[schReqIdx].offset;
5018                break;
5019             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
5020                schReqRsrc->periodicityAndOffset->choice.sl320 = schReqDb->schedAddModList[schReqIdx].offset;
5021                break;
5022             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
5023                schReqRsrc->periodicityAndOffset->choice.sl640 = schReqDb->schedAddModList[schReqIdx].offset;
5024                break;
5025          }
5026       }
5027
5028       if(schReqDb->schedAddModList[schReqIdx].resrc)
5029       {
5030          schReqRsrc->resource = NULLP;
5031          DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
5032          if(schReqRsrc->resource == NULLP)
5033          {
5034             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5035             return RFAILED;
5036          }
5037          *(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
5038
5039       }
5040    }
5041    return ROK;
5042 }
5043
5044 /*******************************************************************
5045  *
5046  * @brief Builds PUCCH multi csi resource list
5047  *
5048  * @details
5049  *
5050  *    Function : BuildPucchMultiCsiRsrcList
5051  *
5052  *    Functionality:
5053  *      Builds PUCCH multi csi resource list
5054  *
5055  * @params[in] : PucchMultiCsiCfg *multiCsiDb
5056  *               struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList
5057  *
5058  * @return ROK     - success
5059  *         RFAILED - failure
5060  *
5061  * ****************************************************************/
5062 uint8_t BuildPucchMultiCsiRsrcList(PucchMultiCsiCfg *multiCsiDb, struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList)
5063 {
5064    uint8_t elementCnt = 0, rsrcIdx = 0;
5065
5066    elementCnt = multiCsiDb->multiCsiResrcListCount;
5067    multiCsiRsrcList->list.count = elementCnt;
5068    multiCsiRsrcList->list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
5069    multiCsiRsrcList->list.array = NULLP;
5070    DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
5071    if(multiCsiRsrcList->list.array == NULLP)
5072    {
5073       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5074       return RFAILED;
5075    }
5076
5077    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5078    {
5079       DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5080       if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
5081       {
5082          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5083          return RFAILED;
5084       }
5085    }
5086
5087    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5088    {
5089       *(multiCsiRsrcList->list.array[rsrcIdx]) = multiCsiDb->multiCsiResrcList[rsrcIdx];
5090    }
5091    return ROK;
5092 }
5093
5094 /*******************************************************************
5095  *
5096  * @brief Builds DL data -to- Ul Ack list
5097  *
5098  * @details
5099  *
5100  *    Function : BuildDlDataToUlAckList
5101  *
5102  *    Functionality: Builds DL data -to- Ul Ack list
5103  *
5104  * @params[in] : PucchDlDataToUlAck *dlDataToUlAckDb
5105  *               struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList
5106  *
5107  * @return ROK     - success
5108  *         RFAILED - failure
5109  *
5110  * ****************************************************************/
5111 uint8_t BuildDlDataToUlAckList(PucchDlDataToUlAck *dlDataToUlAckDb, struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList)
5112 {
5113    uint8_t elementCnt = 0, arrIdx = 0;
5114
5115    if(dlDataToUlAckDb == NULLP)
5116       elementCnt = 2;
5117    else
5118       elementCnt = dlDataToUlAckDb->dlDataToUlAckListCount;
5119
5120    dlDataToUlACKList->list.count = elementCnt;
5121    dlDataToUlACKList->list.size = elementCnt * sizeof(long *);
5122    DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
5123    if(dlDataToUlACKList->list.array == NULLP)
5124    {
5125       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5126       return RFAILED;
5127    }
5128
5129    for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5130    {
5131       DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
5132       if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
5133       {
5134          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5135          return RFAILED;
5136       }
5137    }
5138
5139    if(dlDataToUlAckDb == NULLP)
5140    {
5141       arrIdx = 0;
5142       *(dlDataToUlACKList->list.array[arrIdx++]) = 1;
5143       *(dlDataToUlACKList->list.array[arrIdx]) = 2;
5144    }
5145    else
5146    {
5147       for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5148       {
5149          *(dlDataToUlACKList->list.array[arrIdx]) = dlDataToUlAckDb->dlDataToUlAckList[arrIdx];
5150       }
5151    }
5152    return ROK;
5153 }
5154
5155 /*******************************************************************
5156  *
5157  * @brief Builds BWP UL dedicated PUCCH Config
5158  *
5159  * @details
5160  *
5161  *    Function : BuildBWPUlDedPucchCfg
5162  *
5163  *    Functionality:
5164  *      Builds BWP UL dedicated PUCCH Config
5165  *
5166  * @params[in] : PUCCH_Config_t *pucchCfg
5167  *
5168  * @return ROK     - success
5169  *         RFAILED - failure
5170  *
5171  * ****************************************************************/
5172 uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg)
5173 {
5174    PucchResrcSetCfg *rsrcSetCfgDb = NULLP;
5175    PucchResrcCfg *rsrcCfgDb = NULLP;
5176    PucchFormatCfg *format1Db = NULLP;
5177    PucchFormatCfg *format2Db = NULLP;
5178    PucchFormatCfg *format3Db = NULLP;
5179    PucchFormatCfg *format4Db = NULLP;
5180    PucchSchedReqCfg *schReqDb = NULLP;
5181    PucchMultiCsiCfg  *multiCsiDb = NULLP;
5182    PucchDlDataToUlAck *dlDataToUlAckDb = NULLP;
5183
5184    if(pucchCfgDb)
5185    {
5186       rsrcSetCfgDb = pucchCfgDb->resrcSet;
5187       rsrcCfgDb = pucchCfgDb->resrc;
5188       format1Db = pucchCfgDb->format1;
5189       format2Db = pucchCfgDb->format2;
5190       format3Db = pucchCfgDb->format3;
5191       format4Db = pucchCfgDb->format4;
5192       schReqDb = pucchCfgDb->schedReq;
5193       multiCsiDb = pucchCfgDb->multiCsiCfg;
5194       dlDataToUlAckDb = pucchCfgDb->dlDataToUlAck;
5195    }
5196
5197    /* RESOURCE SET */
5198    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5199    if(pucchCfg->resourceSetToAddModList == NULL)
5200    {
5201       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5202       return RFAILED;
5203    }
5204
5205    if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
5206    {
5207       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5208       return RFAILED;
5209    }
5210
5211    /* PUCCH RESOURCE */
5212    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5213    if(pucchCfg->resourceToAddModList == NULLP)
5214    {
5215       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5216       return RFAILED;
5217    }
5218
5219    if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
5220    {
5221       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5222       return RFAILED;
5223    }
5224
5225    /* PUCCH Format 1 */
5226    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5227    if(pucchCfg->format1 == NULLP)
5228    {
5229       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5230       return RFAILED;
5231    }
5232
5233    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
5234    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5235    if(pucchCfg->format1->choice.setup == NULLP)
5236    {
5237       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5238       return RFAILED;
5239    }
5240
5241    if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
5242    {
5243       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5244       return RFAILED;
5245    }
5246
5247    /* PUCCH Format 2 */
5248    if(format2Db)
5249    {
5250       DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
5251       if(pucchCfg->format2 == NULLP)
5252       {
5253          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5254          return RFAILED;
5255       }
5256
5257       pucchCfg->format2->present = PUCCH_Config__format2_PR_setup;
5258       DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
5259       if(pucchCfg->format2->choice.setup == NULLP)
5260       {
5261          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5262          return RFAILED;
5263       }
5264
5265       if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
5266       {
5267          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5268          return RFAILED;
5269       }
5270    }
5271
5272    /* PUCCH Format 3 */
5273    if(format3Db)
5274    {
5275       DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
5276       if(pucchCfg->format3 == NULLP)
5277       {
5278          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5279          return RFAILED;
5280       }
5281
5282       pucchCfg->format3->present = PUCCH_Config__format3_PR_setup;
5283       DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
5284       if(pucchCfg->format3->choice.setup == NULLP)
5285       {
5286          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5287          return RFAILED;
5288       }
5289
5290       if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
5291       {
5292          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5293          return RFAILED;
5294       }
5295    }
5296
5297    /* PUCCH Format 4 */
5298    if(format4Db)
5299    {
5300       DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
5301       if(pucchCfg->format4 == NULLP)
5302       {
5303          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5304          return RFAILED;
5305       }
5306
5307       pucchCfg->format4->present = PUCCH_Config__format4_PR_setup;
5308       DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
5309       if(pucchCfg->format4->choice.setup == NULLP)
5310       {
5311          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5312          return RFAILED;
5313       }
5314
5315       if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
5316       {
5317          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5318          return RFAILED;
5319       }
5320    }
5321
5322    /* Scheduling Request */
5323    if(schReqDb && (schReqDb->schedAddModListCount != 0))
5324    {
5325       pucchCfg->schedulingRequestResourceToAddModList = NULLP;
5326       DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
5327       if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
5328       {
5329          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5330          return RFAILED;
5331       }
5332
5333       if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
5334       {
5335          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5336          return RFAILED;
5337       }
5338    }
5339
5340    /* Multi CSI */
5341    if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
5342    {
5343       pucchCfg->multi_CSI_PUCCH_ResourceList = NULLP;
5344       DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
5345       if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
5346       {
5347          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5348          return RFAILED;
5349       }
5350
5351       if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
5352       {
5353          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5354          return RFAILED;
5355       }
5356    }
5357
5358    /* DL DATA TO UL ACK */
5359    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5360    if(pucchCfg->dl_DataToUL_ACK == NULLP)
5361    {
5362       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5363       return RFAILED;
5364    }
5365
5366    if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
5367    {
5368       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5369       return RFAILED;
5370    }
5371
5372    /* TODO : spatial relation info add/mod list and power control*/
5373
5374    return ROK;
5375 }
5376
5377 /*******************************************************************
5378  *
5379  * @brief Fills SRS resource to add/modify list
5380  *
5381  * @details
5382  *
5383  *    Function : BuildSrsRsrcAddModList
5384  *
5385  *    Functionality: Fills SRS resource to add/modify list
5386  *
5387  * @params[in]
5388  * @return ROK     - success
5389  *         RFAILED - failure
5390  *
5391  * ****************************************************************/
5392 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
5393 {
5394    uint8_t   elementCnt;
5395    uint8_t   rsrcIdx;
5396
5397    elementCnt = 1;
5398    resourceList->list.count = elementCnt;
5399    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
5400    resourceList->list.array = NULLP;
5401    DU_ALLOC(resourceList->list.array, resourceList->list.size);
5402    if(!resourceList->list.array)
5403    {
5404       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5405       return RFAILED;
5406    }
5407
5408    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5409    {
5410       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5411       if(!resourceList->list.array[rsrcIdx])
5412       {
5413          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5414          return RFAILED;
5415       }
5416    }
5417
5418    rsrcIdx = 0;
5419    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
5420    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
5421    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
5422
5423    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
5424    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
5425          sizeof(struct SRS_Resource__transmissionComb__n2));
5426    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
5427    {
5428       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5429       return RFAILED;
5430    }
5431    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
5432       = SRS_COMB_OFFSET_N2;
5433    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
5434       = SRS_CYCLIC_SHIFT_N2;
5435
5436    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
5437                                                                       PUSCH_START_SYMBOL;
5438    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
5439                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
5440    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
5441                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
5442
5443    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
5444    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
5445    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
5446    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
5447    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
5448    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
5449                                                                SRS_Resource__groupOrSequenceHopping_neither;
5450
5451    /* Setting resource type to aperiodic for intergration purposes */
5452    resourceList->list.array[rsrcIdx]->resourceType.present = \
5453                                                              SRS_Resource__resourceType_PR_aperiodic;
5454    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
5455    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
5456          sizeof(struct SRS_Resource__resourceType__aperiodic));
5457    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
5458    {
5459       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5460       return RFAILED;
5461    }
5462    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
5463
5464    return ROK;
5465 }
5466
5467 /*******************************************************************
5468  *
5469  * @brief Build SRS resource set Add/mod list
5470  *
5471  * @details
5472  *
5473  *    Function : BuildSrsRsrcSetAddModList
5474  *
5475  *    Functionality: Build SRS resource set Add/mod list
5476  *
5477  * @params[in]
5478  * @return ROK     - success
5479  *         RFAILED - failure
5480  *
5481  * ****************************************************************/
5482    uint8_t BuildSrsRsrcSetAddModList
5483 (
5484  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
5485  )
5486 {
5487    uint8_t  elementCnt;
5488    uint8_t  rSetIdx;
5489    uint8_t  rsrcIdx;
5490    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
5491
5492    elementCnt = 1;
5493    rsrcSetList->list.count = elementCnt;
5494    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
5495    rsrcSetList->list.array = NULLP;
5496    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
5497    if(!rsrcSetList->list.array)
5498    {
5499       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5500       return RFAILED;
5501    }
5502
5503    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5504    {
5505       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5506       if(!rsrcSetList->list.array[rSetIdx])
5507       {
5508          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5509          return RFAILED;
5510       }
5511    }
5512
5513    rSetIdx = 0;
5514    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
5515
5516    /* Fill Resource Id list in resource set */
5517    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
5518    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5519          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5520    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5521    {
5522       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5523       return RFAILED;
5524    }
5525
5526    elementCnt = 1;
5527    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5528    rsrcIdList->list.count = elementCnt;
5529    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
5530    rsrcIdList->list.array = NULLP;
5531    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
5532    if(!rsrcIdList->list.array)
5533    {
5534       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5535       return RFAILED;
5536    }
5537
5538    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5539    {
5540       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5541       if(!rsrcIdList->list.array[rsrcIdx])
5542       {
5543          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5544          return RFAILED;
5545       }
5546    }
5547
5548    rsrcIdx = 0;
5549    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
5550
5551    /* Fill resource type */
5552    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
5553                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
5554
5555    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
5556    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5557          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5558    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
5559    {
5560       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5561       return RFAILED;
5562    }
5563    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
5564       = APERIODIC_SRS_RESRC_TRIGGER;
5565
5566    /* TODO : Fill values for below IEs as expected by Viavi */
5567    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
5568    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
5569
5570
5571    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
5572    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
5573    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
5574    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
5575    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
5576
5577    return ROK;
5578 }
5579
5580 /*******************************************************************
5581  *
5582  * @brief Builds BWP UL dedicated SRS Config
5583  *
5584  * @details
5585  *
5586  *    Function : BuildBWPUlDedSrsCfg
5587  *
5588  *    Functionality: Builds BWP UL dedicated SRS Config
5589  *
5590  * @params[in] SRS Config
5591  * @return ROK     - success
5592  *         RFAILED - failure
5593  *
5594  * ****************************************************************/
5595 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
5596 {
5597    srsCfg->srs_ResourceSetToReleaseList = NULLP;
5598    srsCfg->srs_ResourceSetToAddModList = NULLP;
5599    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
5600          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5601    if(!srsCfg->srs_ResourceSetToAddModList)
5602    {
5603       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5604       return RFAILED;
5605    }
5606    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
5607    {
5608       return RFAILED;
5609    }
5610
5611    srsCfg->srs_ResourceToReleaseList = NULLP;
5612
5613    /* Resource to Add/Modify list */
5614    srsCfg->srs_ResourceToAddModList = NULLP;
5615    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
5616          sizeof(struct SRS_Config__srs_ResourceToAddModList));
5617    if(!srsCfg->srs_ResourceToAddModList)
5618    {
5619       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5620       return RFAILED;
5621    }
5622
5623    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
5624    {
5625       return RFAILED;
5626    }
5627
5628    srsCfg->tpc_Accumulation = NULLP;
5629
5630    return ROK;
5631 }
5632
5633
5634
5635 /*******************************************************************
5636  *
5637  * @brief Builds Pusch Serving cell Config
5638  *
5639  * @details
5640  *
5641  *    Function : BuildPuschSrvCellCfg
5642  *
5643  *    Functionality: Builds Pusch Serving cell Config
5644  *
5645  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
5646  *
5647  * @return ROK     - success
5648  *         RFAILED - failure
5649  *
5650  * ****************************************************************/
5651 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
5652 {
5653    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
5654    puschCfg->choice.setup = NULLP;
5655    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5656    if(!puschCfg->choice.setup)
5657    {
5658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5659       return RFAILED;
5660    }
5661
5662    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5663    puschCfg->choice.setup->rateMatching = NULLP;
5664    puschCfg->choice.setup->xOverhead = NULLP;
5665    puschCfg->choice.setup->ext1 = NULLP;
5666    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
5667    if(!puschCfg->choice.setup->ext1)
5668    {
5669       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5670       return RFAILED;
5671    }
5672
5673    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
5674    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5675    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
5676    {
5677       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5678       return RFAILED;
5679    }
5680    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5681
5682    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5683    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5684    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5685    {
5686       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5687       return RFAILED;
5688    }
5689    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5690    return ROK;
5691 }
5692
5693 /*******************************************************************
5694  *
5695  * @brief Builds inital UL BWP
5696  *
5697  * @details
5698  *
5699  *    Function : BuildInitialUlBWP
5700  *
5701  *    Functionality: Builds initial UL BWP
5702  *
5703  * @params[in] BWP_UplinkDedicated_t *ulBwp
5704  * @return ROK     - success
5705  *         RFAILED - failure
5706  *
5707  * ****************************************************************/
5708 uint8_t BuildInitialUlBWP(InitialUlBwp *initUlBwp, BWP_UplinkDedicated_t *ulBwp)
5709 {
5710    PucchCfg *pucchCfg = NULLP;
5711    PuschCfg *puschCfg = NULLP;
5712
5713    if(initUlBwp)
5714    {
5715       if(initUlBwp->pucchPresent)
5716          pucchCfg = &initUlBwp->pucchCfg;
5717       if(initUlBwp->puschPresent)
5718          puschCfg = &initUlBwp->puschCfg;
5719    }
5720
5721    ulBwp->pucch_Config = NULLP;
5722    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5723    if(!ulBwp->pucch_Config)
5724    {
5725       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5726       return RFAILED;
5727    }
5728
5729    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
5730    ulBwp->pucch_Config->choice.setup = NULLP;
5731    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5732    if(!ulBwp->pucch_Config->choice.setup)
5733    {
5734       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5735       return RFAILED;
5736    }
5737
5738    if(BuildBWPUlDedPucchCfg(pucchCfg, ulBwp->pucch_Config->choice.setup) != ROK)
5739    {
5740       return RFAILED;
5741    }
5742
5743    /* Fill BWP UL dedicated PUSCH config */
5744    ulBwp->pusch_Config = NULLP;
5745    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5746    if(!ulBwp->pusch_Config)
5747    {
5748       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5749       return RFAILED;
5750    }
5751
5752    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
5753    ulBwp->pusch_Config->choice.setup = NULLP;
5754    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5755    if(!ulBwp->pusch_Config->choice.setup)
5756    {
5757       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5758       return RFAILED;
5759    }
5760
5761    if(BuildBWPUlDedPuschCfg(puschCfg, ulBwp->pusch_Config->choice.setup) != ROK)
5762    {
5763       return RFAILED;
5764    }
5765
5766    ulBwp->configuredGrantConfig = NULLP;
5767
5768    /* Fill BPW UL dedicated SRS config */
5769    ulBwp->srs_Config = NULLP;
5770    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5771    if(!ulBwp->srs_Config)
5772    {
5773       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5774       return RFAILED;
5775    }
5776
5777    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
5778    ulBwp->srs_Config->choice.setup = NULLP;
5779    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5780    if(!ulBwp->srs_Config->choice.setup)
5781    {
5782       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5783       return RFAILED;
5784    }
5785
5786    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
5787    {
5788       return RFAILED;
5789    }
5790
5791    ulBwp->beamFailureRecoveryConfig = NULLP;
5792
5793    return ROK;
5794 }
5795
5796 /*******************************************************************
5797  *
5798  * @brief Builds UL config
5799  * @details
5800  *
5801  *    Function : BuildUlCfg
5802  *
5803  *    Functionality: Builds UL config in spCellCfgDed
5804  *
5805  * @params[in] UplinkConfig_t *ulCfg
5806  *
5807  * @return ROK     - success
5808  *         RFAILED - failure
5809  *
5810  * ****************************************************************/
5811 uint8_t BuildUlCfg(ServCellCfgInfo *servCellCfg, UplinkConfig_t *ulCfg)
5812 {
5813    InitialUlBwp *initUlBwp = NULLP;
5814
5815    if(servCellCfg)
5816    {
5817       initUlBwp = &servCellCfg->initUlBwp;
5818    }
5819
5820    ulCfg->initialUplinkBWP = NULLP;
5821    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5822    if(!ulCfg->initialUplinkBWP)
5823    {
5824       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5825       return RFAILED;
5826    }
5827
5828    if(BuildInitialUlBWP(initUlBwp, ulCfg->initialUplinkBWP) != ROK)
5829    {
5830       return RFAILED;
5831    }
5832
5833    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5834    ulCfg->uplinkBWP_ToAddModList = NULLP;
5835    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5836    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5837    if(!ulCfg->firstActiveUplinkBWP_Id)
5838    {
5839       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5840       return RFAILED;
5841    }
5842    if(servCellCfg == NULLP)
5843       *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5844    else
5845       *(ulCfg->firstActiveUplinkBWP_Id) = servCellCfg->firstActvUlBwpId;
5846
5847    ulCfg->pusch_ServingCellConfig = NULLP;
5848    DU_ALLOC(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5849    if(!ulCfg->pusch_ServingCellConfig)
5850    {
5851       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5852       return RFAILED;
5853    }
5854
5855    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5856    {
5857       return RFAILED;
5858    }
5859
5860    ulCfg->carrierSwitching = NULLP;
5861    ulCfg->ext1 = NULLP;
5862    return ROK;
5863 }
5864
5865 /*******************************************************************
5866  *
5867  * @brief Builds PDSCH serving cell config
5868  * @details
5869  *
5870  *    Function : BuildPdschSrvCellCfg
5871  *
5872  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5873  *
5874  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5875  *
5876  * @return ROK     - success
5877  *         RFAILED - failure
5878  *
5879  * ****************************************************************/
5880 uint8_t BuildPdschSrvCellCfg(PdschServCellCfg *pdschServCellDb, struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5881 {
5882    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5883    pdschCfg->choice.setup = NULLP;
5884    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5885    if(!pdschCfg->choice.setup)
5886    {
5887       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5888       return RFAILED;
5889    }
5890
5891    /* Code Block Group Transmission */
5892    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5893    if(pdschServCellDb && (pdschServCellDb->maxCodeBlkGrpPerTb || pdschServCellDb->codeBlkGrpFlushInd))
5894    {
5895       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission, sizeof(struct PDSCH_ServingCellConfig__codeBlockGroupTransmission));
5896       if(pdschCfg->choice.setup->codeBlockGroupTransmission == NULLP)
5897       {
5898          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5899          return RFAILED;
5900       }
5901
5902       pdschCfg->choice.setup->codeBlockGroupTransmission->present = PDSCH_ServingCellConfig__codeBlockGroupTransmission_PR_setup;
5903       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup = NULLP;
5904       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup, sizeof(struct PDSCH_CodeBlockGroupTransmission ));
5905       if(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup == NULLP)
5906       {
5907          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5908          return RFAILED;
5909       }
5910
5911       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock = \
5912          *(pdschServCellDb->maxCodeBlkGrpPerTb);
5913       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator = \
5914          *(pdschServCellDb->codeBlkGrpFlushInd);
5915    }
5916
5917    /* xOverhead */
5918    pdschCfg->choice.setup->xOverhead = NULLP;
5919    if(pdschServCellDb && pdschServCellDb->xOverhead)
5920    {
5921       DU_ALLOC(pdschCfg->choice.setup->xOverhead, sizeof(long));
5922       if(pdschCfg->choice.setup->xOverhead == NULLP)
5923       {
5924          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5925          return RFAILED;
5926       }
5927       *(pdschCfg->choice.setup->xOverhead) = *(pdschServCellDb->xOverhead);
5928    }
5929
5930    /* Number of HARQ processes */
5931    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5932    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5933    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5934    {
5935       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5936       return RFAILED;
5937    }
5938
5939    if(pdschServCellDb == NULLP)
5940    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = PDSCH_NUM_HARQ_PROC;
5941    else
5942    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = pdschServCellDb->numHarqProcForPdsch;
5943
5944    pdschCfg->choice.setup->pucch_Cell = NULLP;
5945
5946    /* Extension */
5947    pdschCfg->choice.setup->ext1 = NULLP;
5948    if(pdschServCellDb && pdschServCellDb->maxMimoLayers)
5949    {
5950       DU_ALLOC(pdschCfg->choice.setup->ext1, sizeof(struct PDSCH_ServingCellConfig__ext1));
5951       if(pdschCfg->choice.setup->ext1 == NULLP)
5952       {
5953          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5954          return RFAILED;
5955       }
5956
5957       DU_ALLOC(pdschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5958       if(pdschCfg->choice.setup->ext1->maxMIMO_Layers == NULLP)
5959       {
5960          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5961          return RFAILED;
5962       }
5963       *(pdschCfg->choice.setup->ext1->maxMIMO_Layers) = *(pdschServCellDb->maxMimoLayers);
5964    }
5965
5966    return ROK;
5967 }
5968
5969 /*******************************************************************
5970  *
5971  * @brief Builds CSI Meas config
5972  * @details
5973  *
5974  *    Function : BuildCsiMeasCfg
5975  *
5976  *    Functionality: Builds CSI Meas config in spCellCfgDed
5977  *
5978  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5979  *
5980  * @return ROK     - success
5981  *         RFAILED - failure
5982  *
5983  * ****************************************************************/
5984 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5985 {
5986
5987    return ROK;
5988 }
5989
5990 /*******************************************************************
5991  *
5992  * @brief Builds DL BWP to add/modify list
5993  * @details
5994  *
5995  *    Function : BuildDlBwpToAddModList
5996  *
5997  *    Functionality: Builds DL BWP to add/modify list
5998  *
5999  * @params[in] ServCellCfgInfo *servCellCfg,
6000  *             struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList
6001  *
6002  * @return ROK     - success
6003  *         RFAILED - failure
6004  *
6005  * ****************************************************************/
6006 uint8_t BuildDlBwpToAddModList(ServCellCfgInfo *servCellCfg, struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList)
6007 {
6008    uint8_t elementCnt, idx;
6009
6010    elementCnt = servCellCfg->numDlBwpToAdd;
6011    dlBwpAddModList->list.count = elementCnt;
6012    dlBwpAddModList->list.size = elementCnt * sizeof(struct BWP_Downlink *);
6013    dlBwpAddModList->list.array = NULLP;
6014    DU_ALLOC(dlBwpAddModList->list.array, dlBwpAddModList->list.size);
6015    if(dlBwpAddModList->list.array == NULLP)
6016    {
6017       DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6018       return RFAILED;
6019    }
6020
6021    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6022    {
6023       DU_ALLOC(dlBwpAddModList->list.array[idx], sizeof(BWP_Downlink_t));
6024       if(dlBwpAddModList->list.array[idx] == NULLP)
6025       {
6026          DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6027          return RFAILED;
6028       }
6029    }
6030
6031    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6032    {
6033       dlBwpAddModList->list.array[idx]->bwp_Id = servCellCfg->DlBwpToAddList[idx].bwpId;
6034       dlBwpAddModList->list.array[idx]->bwp_Common = NULLP;
6035       dlBwpAddModList->list.array[idx]->bwp_Dedicated = NULLP;
6036    }
6037    return ROK;
6038 }
6039
6040 /*******************************************************************
6041  *
6042  * @brief Builds Spcell config dedicated
6043  * @details
6044  *
6045  *    Function : BuildSpCellCfgDed
6046  *
6047  *    Functionality: Builds sp cell config dedicated in spCellCfg
6048  *
6049  * @params[in] ServingCellConfig_t srvCellCfg
6050  *
6051  * @return ROK     - success
6052  *         RFAILED - failure
6053  *
6054  * ****************************************************************/
6055 uint8_t BuildSpCellCfgDed(DuUeCb *ueCb, ServingCellConfig_t *srvCellCfg)
6056 {
6057    ServCellCfgInfo *servCellCfg = NULLP;
6058    InitialDlBwp *initDlBwp = NULLP;
6059    PdschServCellCfg *pdschServCellDb = NULLP;
6060
6061    if(ueCb)
6062    {
6063       servCellCfg = &ueCb->macUeCfg.spCellCfg.servCellCfg;
6064       initDlBwp = &servCellCfg->initDlBwp;
6065       pdschServCellDb = &servCellCfg->pdschServCellCfg;
6066    }
6067
6068    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
6069    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
6070    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
6071    {
6072       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6073       return RFAILED;
6074    }
6075
6076    srvCellCfg->initialDownlinkBWP = NULLP;
6077    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6078    if(!srvCellCfg->initialDownlinkBWP)
6079    {
6080       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6081       return RFAILED;
6082    }
6083
6084    if(BuildInitialDlBWP(initDlBwp, srvCellCfg->initialDownlinkBWP) != ROK)
6085    {
6086       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6087       return RFAILED;
6088    }
6089
6090    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
6091
6092    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
6093    if(ueCb && ueCb->macUeCfg.spCellCfg.servCellCfg.numDlBwpToAdd)
6094    {
6095       DU_ALLOC(srvCellCfg->downlinkBWP_ToAddModList, sizeof(struct ServingCellConfig__downlinkBWP_ToAddModList));
6096       if(srvCellCfg->downlinkBWP_ToAddModList == NULLP)
6097       {
6098          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6099          return RFAILED;
6100       }
6101
6102       if(BuildDlBwpToAddModList(&ueCb->macUeCfg.spCellCfg.servCellCfg, srvCellCfg->downlinkBWP_ToAddModList) != ROK)
6103       {
6104          DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6105          return RFAILED;
6106       }
6107    }
6108
6109    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
6110    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6111    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
6112    {
6113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6114       return RFAILED;
6115    }
6116    if(ueCb == NULLP)
6117       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6118    else
6119       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.firstActvDlBwpId;
6120
6121    srvCellCfg->bwp_InactivityTimer = NULLP;
6122
6123    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
6124    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6125    if(!srvCellCfg->defaultDownlinkBWP_Id)
6126    {
6127       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6128       return RFAILED;
6129    }
6130    if(ueCb == NULLP)
6131       *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6132    else
6133       *(srvCellCfg->defaultDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.defaultDlBwpId;
6134
6135    srvCellCfg->uplinkConfig = NULLP;
6136    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6137    if(!srvCellCfg->uplinkConfig)
6138    {
6139       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6140       return RFAILED;
6141    }
6142
6143    if(BuildUlCfg(servCellCfg, srvCellCfg->uplinkConfig) != ROK)
6144    {
6145       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
6146       return RFAILED;
6147    }
6148    srvCellCfg->supplementaryUplink = NULLP;
6149    srvCellCfg->pdcch_ServingCellConfig = NULLP;
6150
6151    srvCellCfg->pdsch_ServingCellConfig = NULLP;
6152    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
6153    if(!srvCellCfg->pdsch_ServingCellConfig)
6154    {
6155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6156       return RFAILED;
6157    }
6158
6159    if(BuildPdschSrvCellCfg(pdschServCellDb, srvCellCfg->pdsch_ServingCellConfig) != ROK)
6160    {
6161       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
6162       return RFAILED;
6163    }
6164
6165    srvCellCfg->csi_MeasConfig = NULLP;
6166 #if 0
6167    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
6168       if(!srvCellCfg->csi_MeasConfig)
6169       {
6170          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6171          return RFAILED;
6172       }
6173
6174    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
6175    {
6176       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
6177       return RFAILED;
6178    }
6179 #endif
6180    srvCellCfg->sCellDeactivationTimer = NULLP;
6181    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
6182    srvCellCfg->tag_Id = TAG_ID;
6183    srvCellCfg->dummy = NULLP;
6184    srvCellCfg->pathlossReferenceLinking = NULLP;
6185    srvCellCfg->servingCellMO = NULLP;
6186    srvCellCfg->ext1 = NULLP;
6187
6188    return ROK;
6189 }
6190 /*******************************************************************
6191  *
6192  * @brief Builds Spcell config
6193  *
6194  * @details
6195  *
6196  *    Function : BuildSpCellCfg
6197  *
6198  *    Functionality: Builds sp cell config in DuToCuRrcContainer
6199  *
6200  * @params[in] SpCellConfig_t spCellCfg
6201  *
6202  * @return ROK     - success
6203  *         RFAILED - failure
6204  *
6205  * ****************************************************************/
6206 uint8_t BuildSpCellCfg(DuUeCb *ueCb, SpCellConfig_t *spCellCfg)
6207 {
6208    spCellCfg->servCellIndex = NULLP;
6209    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
6210    if(!spCellCfg->servCellIndex)
6211    {
6212       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6213       return RFAILED;
6214    }
6215
6216    if(ueCb == NULLP)
6217       *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
6218    else
6219       *(spCellCfg->servCellIndex) = ueCb->macUeCfg.spCellCfg.servCellIdx;
6220
6221    spCellCfg->reconfigurationWithSync = NULLP;
6222    spCellCfg->rlf_TimersAndConstants = NULLP;
6223    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
6224
6225    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6226    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
6227    {
6228       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6229       return RFAILED;
6230    }
6231    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
6232
6233    spCellCfg->spCellConfigDedicated = NULLP;
6234    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6235    if(!spCellCfg->spCellConfigDedicated)
6236    {
6237       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6238       return RFAILED;
6239    }
6240    if(BuildSpCellCfgDed(ueCb, spCellCfg->spCellConfigDedicated) != ROK)
6241    {
6242       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
6243       return RFAILED;
6244    }
6245
6246    return ROK;
6247 }
6248
6249 /*******************************************************************
6250  *
6251  * @brief Builds Phy cell group config
6252  *
6253  * @details
6254  *
6255  *    Function : BuildPhyCellGrpCfg
6256  *
6257  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
6258  *
6259  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
6260  *
6261  * @return ROK     - success
6262  *         RFAILED - failure
6263  *
6264  * ****************************************************************/
6265 uint8_t BuildPhyCellGrpCfg(DuUeCb *ueCb, PhysicalCellGroupConfig_t *phyCellGrpCfg)
6266 {
6267    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
6268    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
6269
6270    phyCellGrpCfg->p_NR_FR1 = NULLP;
6271    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6272    if(!phyCellGrpCfg->p_NR_FR1)
6273    {
6274       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
6275       return RFAILED;
6276    }
6277
6278    if(ueCb == NULLP)
6279    {
6280       *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
6281       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
6282    }
6283    else
6284    {
6285       *(phyCellGrpCfg->p_NR_FR1) = ueCb->macUeCfg.phyCellGrpCfg.pNrFr1;
6286       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = ueCb->macUeCfg.phyCellGrpCfg.pdschHarqAckCodebook;
6287    }
6288
6289    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
6290    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
6291    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
6292    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
6293    phyCellGrpCfg->cs_RNTI = NULLP;
6294    phyCellGrpCfg->ext1 = NULLP;
6295    phyCellGrpCfg->ext2 = NULLP;
6296
6297    return ROK;
6298 }
6299
6300 /*******************************************************************
6301  *
6302  * @brief Builds Mac cell group config
6303  *
6304  * @details
6305  *
6306  *    Function : BuildMacCellGrpCfg
6307  *
6308  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
6309  *
6310  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
6311  *
6312  * @return ROK     - success
6313  *         RFAILED - failure
6314  *
6315  * ****************************************************************/
6316 uint8_t BuildMacCellGrpCfg(DuUeCb *ueCb, MAC_CellGroupConfig_t *macCellGrpCfg)
6317 {
6318    macCellGrpCfg->drx_Config = NULLP;
6319    macCellGrpCfg->schedulingRequestConfig = NULLP;
6320    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6321    if(!macCellGrpCfg->schedulingRequestConfig)
6322    {
6323       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6324       return RFAILED;
6325    }
6326
6327    if(BuildSchedulingReqConfig(ueCb, macCellGrpCfg->schedulingRequestConfig) != ROK)
6328    {
6329       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
6330       return RFAILED;
6331    }
6332
6333    macCellGrpCfg->bsr_Config = NULLP;
6334    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6335    if(!macCellGrpCfg->bsr_Config)
6336    {
6337       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6338       return RFAILED;
6339    }
6340
6341    if(BuildBsrConfig(ueCb, macCellGrpCfg->bsr_Config) != ROK)
6342    {
6343       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
6344       return RFAILED;
6345    }
6346
6347    macCellGrpCfg->tag_Config = NULLP;
6348    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
6349    if(!macCellGrpCfg->tag_Config)
6350    {
6351       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6352       return RFAILED;
6353    }
6354
6355    if(BuildTagConfig(ueCb, macCellGrpCfg->tag_Config) != ROK)
6356    {
6357       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
6358       return RFAILED;
6359    }
6360
6361    macCellGrpCfg->phr_Config = NULLP;
6362    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
6363    if(!macCellGrpCfg->phr_Config)
6364    {
6365       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6366       return RFAILED;
6367    }
6368
6369    if(BuildPhrConfig(ueCb, macCellGrpCfg->phr_Config) != ROK)
6370    {
6371       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
6372       return RFAILED;
6373    }
6374
6375    macCellGrpCfg->skipUplinkTxDynamic = false;
6376    macCellGrpCfg->ext1 = NULLP;
6377
6378    return ROK;
6379 }
6380 /*******************************************************************
6381  *
6382  * @brief Frees memeory allocated for SearchSpcToAddModList
6383  *
6384  * @details
6385  *
6386  *    Function : FreeSearchSpcToAddModList
6387  *
6388  *    Functionality: Deallocating memory of SearchSpcToAddModList
6389  *
6390  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6391  *
6392  * @return void
6393  *
6394  4221 * ****************************************************************/
6395 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6396 {
6397    uint8_t idx1=0;
6398    uint8_t idx2=0;
6399    struct  SearchSpace *searchSpc=NULLP;
6400
6401    if(searchSpcList->list.array)
6402    {
6403       if(searchSpcList->list.array[idx2])
6404       {
6405          searchSpc = searchSpcList->list.array[idx2];
6406          if(searchSpc->controlResourceSetId)
6407          {
6408             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6409             {
6410                if(searchSpc->monitoringSymbolsWithinSlot)
6411                {
6412                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6413                   {
6414                      if(searchSpc->nrofCandidates)
6415                      {
6416                         if(searchSpc->searchSpaceType)
6417                         {
6418                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
6419                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
6420                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
6421                                     SearchSpace__searchSpaceType));
6422                         }
6423                         DU_FREE(searchSpc->nrofCandidates,
6424                               sizeof(struct SearchSpace__nrofCandidates));
6425                      }
6426                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
6427                            searchSpc->monitoringSymbolsWithinSlot->size);
6428                   }
6429                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
6430                         sizeof(BIT_STRING_t));
6431                }
6432                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
6433                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
6434             }
6435             DU_FREE(searchSpc->controlResourceSetId,
6436                   sizeof(ControlResourceSetId_t));
6437          }
6438       }
6439       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
6440       {
6441          DU_FREE(searchSpcList->list.array[idx1],
6442                sizeof(struct SearchSpace));
6443       }
6444       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
6445    }
6446 }
6447 /*******************************************************************
6448  *
6449  * @brief Frees memory allocated for PdschTimeDomAllocList
6450  *
6451  * @details
6452  *
6453  *    Function : FreePdschTimeDomAllocList
6454  *
6455  *    Functionality: Deallocating memory of PdschTimeDomAllocList
6456  *
6457  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6458  *
6459  * @return void
6460  *
6461  * ****************************************************************/
6462 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6463 {
6464    uint8_t idx1=0;
6465
6466    if(timeDomAllocList->choice.setup)
6467    {
6468       if(timeDomAllocList->choice.setup->list.array)
6469       {
6470          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
6471          {
6472             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
6473             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
6474                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
6475          }
6476          DU_FREE(timeDomAllocList->choice.setup->list.array, \
6477                timeDomAllocList->choice.setup->list.size);
6478       }
6479       DU_FREE(timeDomAllocList->choice.setup,\
6480             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
6481    }
6482 }
6483 /*******************************************************************
6484  *
6485  * @brief Frees memory allocated for PuschTimeDomAllocList
6486  *
6487  *@details
6488  *
6489  *    Function : FreePuschTimeDomAllocList
6490  *
6491  *    Functionality: Deallocating memory of PuschTimeDomAllocList
6492  *
6493  * @params[in] PUSCH_Config_t *puschCfg
6494  *
6495  * @return void
6496  *
6497  * ****************************************************************/
6498 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
6499 {
6500    uint8_t rsrcListIdx=0;
6501    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6502
6503    if(puschCfg->pusch_TimeDomainAllocationList)
6504    {
6505       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6506       if(timeDomAllocList_t->choice.setup)
6507       {
6508          if(timeDomAllocList_t->choice.setup->list.array)
6509          {
6510             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
6511             {
6512                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
6513                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
6514                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
6515             }
6516             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
6517                   timeDomAllocList_t->choice.setup->list.size);
6518          }
6519          DU_FREE(timeDomAllocList_t->choice.setup, \
6520                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
6521       }
6522       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
6523       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
6524             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
6525    }
6526
6527 }
6528
6529 /*******************************************************************
6530  *
6531  * @brief Frees memory allocated for Dedicated PUCCH config
6532  *
6533  * @details
6534  *
6535  *    Function : FreeBWPUlDedPucchCfg
6536  *
6537  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
6538  *
6539  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
6540  *
6541  * @return void
6542  *
6543  * ****************************************************************/
6544 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
6545 {
6546    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
6547    PUCCH_Config_t *pucchCfg = NULLP;
6548    PUCCH_ResourceSet_t *rsrcSet = NULLP;
6549    PUCCH_Resource_t *rsrc = NULLP;
6550
6551    if(ulBwpPucchCfg)
6552    {
6553       if(ulBwpPucchCfg->choice.setup)
6554       {
6555          pucchCfg = ulBwpPucchCfg->choice.setup;
6556
6557          //Free resource set list
6558          if(pucchCfg->resourceSetToAddModList)
6559          {
6560             if(pucchCfg->resourceSetToAddModList->list.array)
6561             {
6562                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
6563                {
6564                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
6565                   if(rsrcSet->resourceList.list.array)
6566                   {
6567                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
6568                      {
6569                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
6570                      }
6571                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
6572                   }
6573                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
6574                }
6575                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
6576             }
6577             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
6578          }
6579
6580          //Free resource list
6581          if(pucchCfg->resourceToAddModList)
6582          {
6583             if(pucchCfg->resourceToAddModList->list.array)
6584             {
6585                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
6586                {
6587                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
6588                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
6589                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
6590                }
6591                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
6592             }
6593             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
6594          }
6595
6596          //PUCCH Format 1
6597          if(pucchCfg->format1)
6598          {
6599             if(pucchCfg->format1->choice.setup)
6600             {
6601                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
6602                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
6603             }
6604             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
6605          }
6606
6607          //DL DATA TO UL ACK
6608          if(pucchCfg->dl_DataToUL_ACK)
6609          {
6610             if(pucchCfg->dl_DataToUL_ACK->list.array)
6611             {
6612                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
6613                {
6614                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
6615                }
6616                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
6617             }
6618             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
6619          }
6620
6621          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
6622       }
6623       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
6624    }
6625 }
6626
6627 /*******************************************************************
6628  *
6629  * @brief Frees memory allocated for InitialUlBWP
6630  *
6631  * @details
6632  *
6633  *    Function : FreeInitialUlBWP
6634  *
6635  *    Functionality: Deallocating memory of InitialUlBWP
6636  *
6637  * @params[in] BWP_UplinkDedicated_t *ulBwp
6638  *
6639  * @return void
6640  *
6641  * ****************************************************************/
6642 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
6643 {
6644    uint8_t  rSetIdx, rsrcIdx;
6645    SRS_Config_t   *srsCfg = NULLP;
6646    PUSCH_Config_t *puschCfg = NULLP;
6647    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6648    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6649    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6650    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6651
6652    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
6653
6654    if(ulBwp->pusch_Config)
6655    {
6656       if(ulBwp->pusch_Config->choice.setup)
6657       {
6658          puschCfg=ulBwp->pusch_Config->choice.setup;
6659          if(puschCfg->dataScramblingIdentityPUSCH)
6660          {
6661             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6662             {
6663                FreePuschTimeDomAllocList(puschCfg);
6664                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6665                if(dmrsUlCfg->choice.setup)
6666                {
6667                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6668                   {
6669                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6670                      {
6671                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
6672                               sizeof(long));
6673                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
6674                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
6675                      }
6676                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
6677                            sizeof(long));
6678                   }
6679                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
6680                }
6681                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
6682                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
6683             }
6684             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
6685          }
6686          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
6687       }
6688       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
6689
6690       /* Free SRS-Config */
6691       if(ulBwp->srs_Config)
6692       {
6693          if(ulBwp->srs_Config->choice.setup)
6694          {
6695             srsCfg = ulBwp->srs_Config->choice.setup;
6696
6697             /* Free Resource Set to add/mod list */
6698             if(srsCfg->srs_ResourceSetToAddModList)
6699             {
6700                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6701                if(rsrcSetList->list.array)
6702                {
6703                   rSetIdx = 0;
6704
6705                   /* Free SRS resource Id list in this SRS resource set */
6706                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6707                   {
6708                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6709
6710                      if(rsrcIdList->list.array)
6711                      {
6712                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
6713                         {
6714                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
6715                         }
6716                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
6717                      }
6718                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
6719                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
6720                   }
6721
6722                   /* Free resource type info for this SRS resource set */
6723                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
6724                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
6725
6726                   /* Free memory for each resource set */
6727                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6728                   {
6729                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
6730                   }
6731                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
6732                }
6733                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
6734                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
6735             }
6736
6737             /* Free resource to add/modd list */
6738             if(srsCfg->srs_ResourceToAddModList)
6739             {
6740                resourceList = srsCfg->srs_ResourceToAddModList;
6741                if(resourceList->list.array)
6742                {
6743                   rsrcIdx = 0;
6744                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
6745                         sizeof(struct SRS_Resource__transmissionComb__n2));
6746                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
6747                         sizeof(struct SRS_Resource__resourceType__aperiodic));
6748
6749                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6750                   {
6751                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
6752                   }
6753                   DU_FREE(resourceList->list.array, resourceList->list.size);
6754                }
6755                DU_FREE(srsCfg->srs_ResourceToAddModList, \
6756                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
6757             }
6758
6759             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
6760          }
6761          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
6762       }
6763    }
6764 }
6765 /*******************************************************************
6766  *
6767  * @brief Frees memory allocated for initialUplinkBWP
6768  *
6769  * @details
6770  *
6771  *    Function : FreeinitialUplinkBWP
6772  *
6773  *    Functionality: Deallocating memory of initialUplinkBWP
6774  *
6775  * @params[in] UplinkConfig_t *ulCfg
6776  *
6777  * @return void
6778  *
6779  *
6780  * ****************************************************************/
6781 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
6782 {
6783    BWP_UplinkDedicated_t *ulBwp=NULLP;
6784    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6785
6786    if(ulCfg->initialUplinkBWP)
6787    {
6788       ulBwp=ulCfg->initialUplinkBWP;
6789       if(ulCfg->firstActiveUplinkBWP_Id)
6790       {
6791          if(ulCfg->pusch_ServingCellConfig)
6792          {
6793             puschCfg=ulCfg->pusch_ServingCellConfig;
6794             if(puschCfg->choice.setup)
6795             {
6796                if(puschCfg->choice.setup->ext1)
6797                {
6798                   DU_FREE(puschCfg->choice.setup->ext1->\
6799                         processingType2Enabled,sizeof(BOOLEAN_t));
6800                   DU_FREE(puschCfg->choice.setup->ext1->\
6801                         maxMIMO_Layers,sizeof(long));
6802                   DU_FREE(puschCfg->choice.setup->ext1, \
6803                         sizeof(struct PUSCH_ServingCellConfig__ext1));
6804                }
6805                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
6806             }
6807             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
6808          }
6809          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
6810       }
6811       FreeInitialUlBWP(ulBwp);
6812       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
6813    }
6814 }
6815 /*******************************************************************
6816  *
6817  * @brief Frees emmory allocated for BWPDlDedPdschCfg
6818  *
6819  * @details
6820  *
6821  *    Function : FreeBWPDlDedPdschCfg
6822  *
6823  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
6824  *
6825  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6826  *
6827  * @return void
6828  *
6829  *
6830  * ****************************************************************/
6831 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
6832 {
6833    struct PDSCH_Config *pdschCfg=NULLP;
6834    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6835    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6836    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6837
6838    if(dlBwp->pdsch_Config->choice.setup)
6839    {
6840       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6841       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6842       {
6843          if(pdschCfg->pdsch_TimeDomainAllocationList)
6844          {
6845             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6846             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6847             {
6848                prbBndlType=&pdschCfg->prb_BundlingType;
6849                DU_FREE(prbBndlType->choice.staticBundling,\
6850                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
6851                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
6852             }
6853             FreePdschTimeDomAllocList(timeDomAllocList);
6854             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
6855                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
6856          }
6857          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6858          if(dmrsDlCfg->choice.setup)
6859          {
6860             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
6861                   sizeof(long));
6862             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
6863          }
6864          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
6865                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6866       }
6867       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6868    }
6869 }
6870 /*******************************************************************
6871  *
6872  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6873  *
6874  * @details
6875  *
6876  *    Function : FreeBWPDlDedPdcchCfg
6877  *
6878  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6879  *
6880  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6881  *
6882  * @return void
6883  *
6884  *
6885  * ****************************************************************/
6886 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6887 {
6888    uint8_t idx1=0;
6889    uint8_t idx2=0;
6890    struct PDCCH_Config *pdcchCfg=NULLP;
6891    struct ControlResourceSet *controlRSet=NULLP;
6892    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6893
6894    if(dlBwp->pdcch_Config->choice.setup)
6895    {
6896       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6897       if(pdcchCfg->controlResourceSetToAddModList)
6898       {
6899          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6900          if(controlRSetList->list.array)
6901          {
6902             controlRSet = controlRSetList->list.array[idx2];
6903             if(controlRSet)
6904             {
6905                if(controlRSet->frequencyDomainResources.buf)
6906                {
6907                   if(controlRSet->pdcch_DMRS_ScramblingID)
6908                   {
6909                      if(pdcchCfg->searchSpacesToAddModList)
6910                      {
6911                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6912                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
6913                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6914                      }
6915                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6916                   }
6917                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
6918                         controlRSet->frequencyDomainResources.size);
6919                }
6920             }
6921             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6922             {
6923                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6924             }
6925             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6926          }
6927          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6928                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6929       }
6930       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6931    }
6932 }
6933
6934 /*******************************************************************
6935  *
6936  * @brief Frees emmory allocated for DUToCURRCContainer
6937  *
6938  * @details
6939  *
6940  *    Function : FreeMemDuToCuRrcCont
6941  *
6942  *    Functionality: Deallocating memory of DuToCuRrcContainer
6943  *
6944  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
6945  *
6946  * @return ROK     - success
6947  *         RFAILED - failure
6948  *
6949  * ****************************************************************/
6950 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
6951 {
6952    uint8_t idx=0;
6953    SpCellConfig_t *spCellCfg=NULLP;
6954    ServingCellConfig_t *srvCellCfg=NULLP;
6955    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6956    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6957    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6958    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6959    struct RLC_Config *rlcConfig=NULLP;
6960    struct LogicalChannelConfig *macLcConfig=NULLP;
6961    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6962    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6963    struct TAG_Config *tagConfig=NULLP;
6964    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6965    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6966    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6967
6968    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6969    if(rlcBearerList)
6970    {
6971       if(rlcBearerList->list.array)
6972       {
6973          for(idx=0; idx<rlcBearerList->list.count; idx++)
6974          {
6975             if(rlcBearerList->list.array[idx])
6976             {
6977                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6978                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6979                if(rlcConfig)
6980                {
6981                   if(rlcConfig->choice.am)
6982                   {
6983                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6984                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6985                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6986                   }
6987                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
6988                }
6989                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6990                if(macLcConfig)
6991                {
6992                   if(macLcConfig->ul_SpecificParameters)
6993                   {
6994                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6995                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6996                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6997                   }
6998                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6999                }
7000                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
7001             }
7002          }
7003          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
7004       }
7005       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
7006    }
7007
7008    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
7009    if(macCellGrpCfg)
7010    {
7011       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
7012       if(schedulingRequestConfig)
7013       {
7014          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
7015          if(schReqList)
7016          {
7017             if(schReqList->list.array)
7018             {
7019                for(idx=0;idx<schReqList->list.count; idx++)
7020                {
7021                   if(schReqList->list.array[idx])
7022                   {
7023                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
7024                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
7025                   }
7026                }
7027                DU_FREE(schReqList->list.array, schReqList->list.size);
7028             }
7029             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
7030                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
7031             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
7032       }
7033       if(macCellGrpCfg->bsr_Config)
7034       {
7035          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
7036       }
7037       tagConfig = macCellGrpCfg->tag_Config;
7038       if(tagConfig)
7039       {
7040          tagList = tagConfig->tag_ToAddModList;
7041          if(tagList)
7042          {
7043             if(tagList->list.array)
7044             {
7045                for(idx=0; idx<tagList->list.count; idx++)
7046                {
7047                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
7048                }
7049                DU_FREE(tagList->list.array, tagList->list.size);
7050             }
7051             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
7052          }
7053          DU_FREE(tagConfig, sizeof(struct TAG_Config));
7054       }
7055
7056       phrConfig = macCellGrpCfg->phr_Config;
7057       if(phrConfig)
7058       {
7059          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
7060          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
7061       }
7062
7063       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
7064    }
7065
7066    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7067    if(phyCellGrpCfg)
7068    {
7069       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
7070       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
7071    }
7072
7073    spCellCfg = cellGrpCfg->spCellConfig;
7074    if(spCellCfg)
7075    {
7076       if(spCellCfg->servCellIndex)
7077       {
7078          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7079          {
7080             if(spCellCfg->spCellConfigDedicated)
7081             {
7082                srvCellCfg = spCellCfg->spCellConfigDedicated;
7083                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
7084                {
7085                   if(srvCellCfg->initialDownlinkBWP)
7086                   {
7087                      dlBwp = srvCellCfg->initialDownlinkBWP;
7088                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7089                      {
7090                         if(srvCellCfg->defaultDownlinkBWP_Id)
7091                         {
7092                            if(srvCellCfg->uplinkConfig)
7093                            {
7094                               if(srvCellCfg->pdsch_ServingCellConfig)
7095                               {
7096                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
7097                                  if(pdschCfg->choice.setup)
7098                                  {
7099                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
7100                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
7101                                  }
7102                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
7103                                           ServingCellConfig__pdsch_ServingCellConfig));
7104                               }
7105                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
7106                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
7107                            }
7108                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
7109                         }
7110                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
7111                      }
7112                      if(dlBwp->pdcch_Config)
7113                      {
7114                         if(dlBwp->pdsch_Config)
7115                         {
7116                            FreeBWPDlDedPdschCfg(dlBwp);
7117                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
7118                         }
7119                         FreeBWPDlDedPdcchCfg(dlBwp);
7120                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
7121                      }
7122                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
7123                   }
7124                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
7125                }
7126                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
7127             }
7128             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
7129          }
7130          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
7131       }
7132       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
7133    }
7134    return ROK;
7135 }
7136
7137 /*******************************************************************
7138  *
7139  * @brief Builds CellGroupConfigRrc for DU To CU RRC Container
7140  *
7141  * @details
7142  *
7143  *    Function : BuildCellGroupConfigRrc
7144  *
7145  *    Functionality: Builds and copied Cell group config buffer into
7146  *       DuToCuRrcContainer
7147  *
7148  * @params[in] idx, index in F1AP msg
7149  *             DuToCuRRCContainer, DuToCuRRCContainer
7150  *
7151  * @return ROK     - success
7152  *         RFAILED - failure
7153  *
7154  * ****************************************************************/
7155 uint8_t BuildCellGroupConfigRrc(DuUeCb *ueCb, OCTET_STRING_t *duToCuRrcContainer)
7156 {
7157    uint8_t  ret = ROK;
7158    CellGroupConfigRrc_t  cellGrpCfg;
7159    asn_enc_rval_t        encRetVal;
7160    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
7161    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
7162
7163    while(true)
7164    {
7165       cellGrpCfg.cellGroupId = CELL_GRP_ID;
7166
7167       cellGrpCfg.rlc_BearerToAddModList = NULLP;
7168       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
7169       if(!cellGrpCfg.rlc_BearerToAddModList)
7170       {
7171          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7172          ret = RFAILED;
7173          break;
7174       }
7175       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList) != ROK)
7176       {
7177          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
7178          ret = RFAILED;
7179          break;
7180       }
7181
7182       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
7183       cellGrpCfg.mac_CellGroupConfig = NULLP;
7184       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
7185       if(!cellGrpCfg.mac_CellGroupConfig)
7186       {
7187          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7188          ret = RFAILED;
7189          break;
7190       }
7191       if(BuildMacCellGrpCfg(ueCb, cellGrpCfg.mac_CellGroupConfig) != ROK)
7192       {
7193          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
7194          ret = RFAILED;
7195          break;
7196       }
7197
7198       cellGrpCfg.physicalCellGroupConfig = NULLP;
7199       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
7200       if(!cellGrpCfg.physicalCellGroupConfig)
7201       {
7202          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7203          ret = RFAILED;
7204          break;
7205       }
7206       if(BuildPhyCellGrpCfg(ueCb, cellGrpCfg.physicalCellGroupConfig) != ROK)
7207       {
7208          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
7209          ret = RFAILED;
7210          break;
7211       }
7212
7213       cellGrpCfg.spCellConfig = NULLP;
7214       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
7215       if(!cellGrpCfg.spCellConfig)
7216       {
7217          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7218          ret = RFAILED;
7219          break;
7220       }
7221       if(BuildSpCellCfg(ueCb, cellGrpCfg.spCellConfig) != ROK)
7222       {
7223          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
7224          ret = RFAILED;
7225          break;
7226       }
7227
7228       cellGrpCfg.sCellToAddModList = NULLP;
7229       cellGrpCfg.sCellToReleaseList = NULLP;
7230       cellGrpCfg.ext1 = NULLP;
7231
7232       /* encode cellGrpCfg into duToCuRrcContainer */
7233       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
7234       memset(encBuf, 0, ENC_BUF_MAX_LEN);
7235       encBufSize = 0;
7236       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
7237       /* Encode results */
7238       if(encRetVal.encoded == ENCODE_FAIL)
7239       {
7240          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
7241                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7242          ret = RFAILED;
7243          break;
7244       }
7245       else
7246       {
7247          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
7248          for(int i=0; i< encBufSize; i++)
7249          {
7250             printf("%x",encBuf[i]);
7251          }
7252       }
7253
7254       duToCuRrcContainer->size = encBufSize;
7255       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
7256       if(!duToCuRrcContainer->buf)
7257       {
7258          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
7259          ret = RFAILED;
7260          break;
7261       }
7262       if(ret == ROK)
7263       {
7264          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
7265       }
7266       break;
7267    }
7268    FreeMemDuToCuRrcCont(&cellGrpCfg);
7269    return ret;
7270 }
7271
7272 /*******************************************************************
7273  *
7274  * @brief Free memory allocated in InitialULRRCMessage
7275  *
7276  * @details
7277  *
7278  *    Function : freeInitUlRrcMsgTransfer
7279  *
7280  *    Functionality: Free memory allocated in InitialULRRCMessage
7281  *
7282  * @params[in]F1AP_PDU_t  *f1apMsg)
7283  *
7284  * @return ROK     - success
7285  *         RFAILED - failure
7286  *
7287  * ****************************************************************/
7288
7289 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
7290 {
7291    uint8_t ieIdx, arrIdx;
7292    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
7293
7294    if(f1apMsg)
7295    {
7296       if(f1apMsg->choice.initiatingMessage)
7297       {
7298          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
7299             choice.InitialULRRCMessageTransfer;
7300          if(initULRRCMsg->protocolIEs.list.array)
7301          {
7302             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
7303             {
7304                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
7305                {
7306                   case ProtocolIE_ID_id_NRCGI:
7307                   {
7308                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
7309                      {
7310                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
7311                         {
7312                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
7313                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
7314                         }
7315                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
7316                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
7317                      }
7318                      break;
7319                   }
7320                   case ProtocolIE_ID_id_RRCContainer:
7321                   {
7322                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
7323                      {
7324                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
7325                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
7326                      }
7327                      break;
7328                   }
7329                   case ProtocolIE_ID_id_DUtoCURRCContainer:
7330                   {
7331                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
7332                      {
7333                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
7334                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
7335                      }
7336                      break;
7337                   }
7338                   default:
7339                      break;
7340                }
7341              }
7342              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
7343              {
7344                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
7345                 {
7346                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
7347                       sizeof(InitialULRRCMessageTransferIEs_t));
7348                 }
7349              }
7350              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
7351           }
7352          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
7353       }
7354       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
7355    }
7356    else
7357    {
7358       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
7359       return RFAILED;
7360    }
7361    return ROK;
7362 }
7363
7364 /*******************************************************************
7365  *
7366  * @brief Builds and sends the InitialULRRCMessage
7367  *
7368  * @details
7369  *
7370  *    Function : BuildAndSendInitialRrcMsgTransfer
7371  *
7372  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
7373  *                   it to the CU through SCTP.
7374  *
7375  * @params[in]
7376  *
7377  * @return ROK     - success
7378  *         RFAILED - failure
7379  *
7380  * ****************************************************************/
7381 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
7382       uint16_t rrcContSize, uint8_t *rrcContainer)
7383 {
7384    uint8_t   ret;
7385    uint8_t   elementCnt;
7386    uint8_t   ieIdx, cellIdx, ueIdx;
7387    DuUeCb    *duUeCb = NULLP;
7388    asn_enc_rval_t  encRetVal;
7389    F1AP_PDU_t  *f1apMsg = NULLP;
7390    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
7391    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
7392
7393    while(true)
7394    {
7395       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
7396       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
7397       if(f1apMsg == NULLP)
7398       {
7399          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
7400          break;
7401       }
7402       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
7403       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
7404       if(f1apMsg->choice.initiatingMessage == NULLP)
7405       {
7406          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
7407          break;
7408       }
7409       f1apMsg->choice.initiatingMessage->procedureCode =\
7410                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
7411       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
7412       f1apMsg->choice.initiatingMessage->value.present = \
7413                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
7414       initULRRCMsg =\
7415                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
7416       elementCnt = 5;
7417       initULRRCMsg->protocolIEs.list.count = elementCnt;
7418       initULRRCMsg->protocolIEs.list.size = \
7419                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
7420       /* Initialize the F1Setup members */
7421       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
7422       if(initULRRCMsg->protocolIEs.list.array == NULLP)
7423       {
7424          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
7425                RRCSetupRequestMessageTransferIEs failed");
7426          break;
7427       }
7428       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
7429       {
7430          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
7431                sizeof(InitialULRRCMessageTransferIEs_t));
7432          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
7433          {
7434             break;
7435          }
7436       }
7437       ieIdx = 0;
7438       /*GNB DU UE F1AP ID*/
7439       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7440                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
7441       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
7442       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
7443                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
7444       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
7445
7446
7447       /*NRCGI*/
7448       ieIdx++;
7449       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7450                                                         ProtocolIE_ID_id_NRCGI;
7451       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
7452       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
7453                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
7454
7455       ret =\
7456            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
7457       if(ret!=ROK)
7458       {
7459          break;
7460       }
7461
7462       /*CRNTI*/
7463       ieIdx++;
7464       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7465                                                         ProtocolIE_ID_id_C_RNTI;
7466       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7467       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
7468                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
7469       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
7470
7471       /*RRCContainer*/
7472       ieIdx++;
7473       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7474                                                         ProtocolIE_ID_id_RRCContainer;
7475       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7476       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
7477                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
7478
7479       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
7480       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
7481             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
7482       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
7483       {
7484          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
7485          break;
7486
7487       }
7488       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
7489             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
7490
7491
7492       /*DUtoCURRCContainer*/
7493       ieIdx++;
7494       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
7495       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7496       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
7497                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
7498
7499       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
7500       {
7501          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
7502          {
7503             if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
7504                   (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti == crnti))
7505             {
7506                duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
7507             }
7508          }
7509       }
7510
7511       ret = BuildCellGroupConfigRrc(duUeCb, &initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
7512       if(ret != ROK)
7513       {
7514          break;
7515       }
7516
7517       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
7518
7519       /* Encode the Intial UL RRC Message transfer as APER */
7520       memset(encBuf, 0, ENC_BUF_MAX_LEN);
7521       encBufSize = 0;
7522       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
7523       /* Encode results */
7524       if(encRetVal.encoded == ENCODE_FAIL)
7525       {
7526          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
7527                structure (at %s)\n",encRetVal.failed_type ? \
7528                encRetVal.failed_type->name : "unknown");
7529          ret = RFAILED;
7530          break;
7531       }
7532       else
7533       {
7534
7535          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
7536                Message transfer\n");
7537          for(int i=0; i< encBufSize; i++)
7538          {
7539             printf("%x",encBuf[i]);
7540          }
7541       }
7542       /* Sending  msg  */
7543       if(sendF1APMsg() != ROK)
7544       {
7545          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
7546          ret = RFAILED;
7547          break;
7548       }
7549       break;
7550    }
7551    freeInitUlRrcMsgTransfer(f1apMsg);
7552    return ret;
7553 }/* End of BuildAndSendInitialRrcMsgTransfer*/
7554
7555 /*****  UE SETUP REQUEST *****/
7556
7557 /*******************************************************************
7558  *
7559  * @brief Free Qos And Snssai Drb Info
7560  *
7561  * @details
7562  *
7563  *    Function : freeDrbQosAndSnssaiInfo
7564  *
7565  *    Functionality: Free Qos And Snssai Drb Info
7566  *
7567  * @params[in] LcCfg *lcCfg,
7568  * @return void
7569  *
7570  * ****************************************************************/
7571 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
7572 {
7573    if(lcCfg->snssai)
7574    {
7575       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
7576    }
7577    if(lcCfg->drbQos)
7578    {
7579       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
7580    }
7581 }
7582
7583 /******************************************************************
7584 *
7585 * @brief Function to delete the RLC Lc cfg from UE APP DB
7586 *
7587 * @details
7588 *
7589 *  Function : freeRlcLcCfg
7590 *
7591 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
7592 *
7593 *
7594  *****************************************************************/
7595
7596 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
7597 {
7598    switch(lcCfg->rlcMode)
7599    {
7600       case RLC_AM :
7601          {
7602             if(lcCfg->u.amCfg)
7603             {
7604                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
7605             }
7606             break;
7607          }
7608       case RLC_UM_BI_DIRECTIONAL :
7609          {
7610             if(lcCfg->u.umBiDirCfg)
7611             {
7612                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7613             }
7614             break;
7615          }
7616       case RLC_UM_UNI_DIRECTIONAL_UL :
7617          {
7618             if(lcCfg->u.umUniDirUlCfg)
7619             {
7620                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7621             }
7622             break;
7623
7624          }
7625       case RLC_UM_UNI_DIRECTIONAL_DL :
7626          {
7627             if(lcCfg->u.umUniDirDlCfg)
7628             {
7629                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7630             }
7631             break;
7632          }
7633       default:
7634          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
7635          break;
7636    }
7637    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
7638 }
7639
7640 /*******************************************************************
7641  *
7642  * @brief Function to free MacLcCfg
7643  *
7644  * @details
7645  *
7646  *    Function : freeMacLcCfg
7647  *
7648  *    Functionality: Function to free MacLcCfg
7649  *
7650  * @params[in] LcCfg *lcCfg,
7651  * @return void
7652  *
7653  * ****************************************************************/
7654
7655 void  freeMacLcCfg(LcCfg *lcCfg)
7656 {
7657     /* Deleting DRBQOS */
7658    if(lcCfg->drbQos)
7659    {
7660       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
7661    }
7662    /* Deleting SNSSAI */
7663    if(lcCfg->snssai)
7664    {
7665       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
7666    }
7667 }
7668 /*******************************************************************
7669  *
7670  * @brief Free UE NR Capability received in UE Context setup request
7671  *
7672  * @details
7673  *
7674  *    Function : freeAperDecodeUeNrCapability
7675  *
7676  *    Functionality:
7677  *       Free UE NR Capability received in UE Context setup request
7678  *
7679  * @params[in]
7680  * @return ROK     - success
7681  *         RFAILED - failure
7682  *
7683  * ****************************************************************/
7684 void freeAperDecodeUeNrCapability(void *ueNrCapability)
7685 {
7686    uint8_t arrIdx =0;
7687    FeatureSets_t *featureSets =NULLP;
7688    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
7689
7690    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
7691    {
7692       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
7693       {
7694          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
7695             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
7696       }
7697       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
7698    }
7699
7700    if(ueNrCap->featureSets)
7701    {
7702       featureSets = ueNrCap->featureSets;
7703       if(featureSets->featureSetsDownlinkPerCC)
7704       {
7705          if(featureSets->featureSetsDownlinkPerCC->list.array)
7706          {
7707             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
7708             {
7709                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
7710                {
7711                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
7712                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
7713                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
7714                }
7715             }
7716             free(featureSets->featureSetsDownlinkPerCC->list.array);
7717          }
7718          free(featureSets->featureSetsDownlinkPerCC);
7719       }
7720       if(featureSets->featureSetsUplinkPerCC)
7721       {
7722          if(featureSets->featureSetsUplinkPerCC->list.array)
7723          {
7724             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
7725             {
7726                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
7727                {
7728                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
7729                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
7730                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
7731                }
7732             }
7733             free(featureSets->featureSetsUplinkPerCC->list.array);
7734          }
7735          free(featureSets->featureSetsUplinkPerCC);
7736       }
7737       free(ueNrCap->featureSets);
7738    }
7739 }
7740
7741 /*******************************************************************
7742 *
7743 * @brief Function to free PdcchSearchSpcToAddModList
7744          where memory allocated by aper_decoder
7745 *
7746 * @details
7747 *
7748 *    Function : freeAperDecodePdcchSearchSpcToAddModList
7749 *
7750 *    Functionality: Function to free PdcchSearchSpcToAddModList
7751 *
7752 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
7753 * @return void
7754 *
7755 * ****************************************************************/
7756
7757 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
7758 {
7759    uint8_t searchSpcArrIdx=0;
7760    uint8_t searchSpcArrIdx1=0;
7761    struct  SearchSpace *searchSpc=NULLP;
7762
7763
7764    if(searchSpcList->list.array)
7765    {
7766       if(searchSpcList->list.array[searchSpcArrIdx1])
7767       {
7768          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
7769          if(searchSpc->controlResourceSetId)
7770          {
7771             if(searchSpc->monitoringSlotPeriodicityAndOffset)
7772             {
7773                if(searchSpc->monitoringSymbolsWithinSlot)
7774                {
7775                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
7776                   {
7777                      if(searchSpc->nrofCandidates)
7778                      {
7779                         if(searchSpc->searchSpaceType)
7780                         {
7781                            free(searchSpc->searchSpaceType->choice.ue_Specific);
7782                            free(searchSpc->searchSpaceType);
7783                         }
7784                         free(searchSpc->nrofCandidates);
7785                      }
7786                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
7787                   }
7788                   free(searchSpc->monitoringSymbolsWithinSlot);
7789                }
7790                free(searchSpc->monitoringSlotPeriodicityAndOffset);
7791             }
7792             free(searchSpc->controlResourceSetId);
7793          }
7794       }
7795       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
7796       {
7797          free(searchSpcList->list.array[searchSpcArrIdx]);
7798       }
7799       free(searchSpcList->list.array);
7800    }
7801 }
7802 /*******************************************************************
7803 *
7804 * @brief Function for free part for the memory allocated by aper_decoder
7805 *
7806 * @details
7807 *
7808 *    Function : freeAperDecodeBWPDlDedPdcchConfig
7809 *
7810 *    Functionality: Function to free BWPDlDedPdcchConfig
7811 *
7812 * @params[in]
7813 * @return void
7814 *
7815 * ****************************************************************/
7816
7817
7818 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
7819 {
7820    uint8_t arrIdx1=0;
7821    uint8_t arrIdx2=0;
7822    struct PDCCH_Config *pdcchCfg=NULLP;
7823    struct ControlResourceSet *controlRSet=NULLP;
7824    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
7825
7826    if(dlBwp->pdcch_Config->choice.setup)
7827    {
7828       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
7829       if(pdcchCfg->controlResourceSetToAddModList)
7830       {
7831          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
7832          if(controlRSetList->list.array)
7833          {
7834             controlRSet = controlRSetList->list.array[arrIdx2];
7835             if(controlRSet)
7836             {
7837                if(controlRSet->frequencyDomainResources.buf)
7838                {
7839                   if(controlRSet->pdcch_DMRS_ScramblingID)
7840                   {
7841                      if(pdcchCfg->searchSpacesToAddModList)
7842                      {
7843                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
7844                         free(pdcchCfg->searchSpacesToAddModList);
7845                      }
7846                      free(controlRSet->pdcch_DMRS_ScramblingID);
7847                   }
7848                   free(controlRSet->frequencyDomainResources.buf);
7849                }
7850             }
7851             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
7852             {
7853                free(controlRSetList->list.array[arrIdx1]);
7854             }
7855             free(controlRSetList->list.array);
7856          }
7857          free(pdcchCfg->controlResourceSetToAddModList);
7858       }
7859       free(dlBwp->pdcch_Config->choice.setup);
7860    }
7861 }
7862 /*******************************************************************
7863 *
7864 * @brief Function to free PdschTimeDomAllocationList
7865 *     where the memory allocated by aper_decoder
7866 *
7867 * @details
7868 *
7869 *    Function : freeAperDecodePdschTimeDomAllocationList
7870 *
7871 *    Functionality: Function to free PdschTimeDomAllocationList
7872 *
7873 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
7874 * @return void
7875 *
7876 * ****************************************************************/
7877
7878
7879 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
7880 {
7881    uint8_t arrIdx=0;
7882
7883    if(timeDomAllocList->choice.setup)
7884    {
7885       if(timeDomAllocList->choice.setup->list.array)
7886       {
7887          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
7888          {
7889             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
7890          }
7891          free(timeDomAllocList->choice.setup->list.array);
7892       }
7893       free(timeDomAllocList->choice.setup);
7894    }
7895 }
7896
7897 /*******************************************************************
7898 *
7899 * @brief Function to free BWPDlDedPdschConfig
7900 *        where the memory allocated by aper_decoder
7901 *
7902 * @details
7903 *
7904 *    Function : freeAperDecodeBWPDlDedPdschConfig
7905 *
7906 *    Functionality: Function to free BWPDlDedPdschConfig
7907 *
7908 * @params[in] BWP_DownlinkDedicated_t *dlBwp
7909 * @return void
7910 *
7911 * ****************************************************************/
7912
7913
7914 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
7915 {
7916    struct PDSCH_Config *pdschCfg=NULLP;
7917    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
7918    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
7919    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
7920
7921    if(dlBwp->pdsch_Config->choice.setup)
7922    {
7923       pdschCfg=dlBwp->pdsch_Config->choice.setup;
7924       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7925       {
7926          if(pdschCfg->pdsch_TimeDomainAllocationList)
7927          {
7928             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
7929             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
7930             {
7931                prbBndlType=&pdschCfg->prb_BundlingType;
7932                free(prbBndlType->choice.staticBundling);
7933                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
7934             }
7935             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
7936             free(pdschCfg->pdsch_TimeDomainAllocationList);
7937          }
7938          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
7939          if(dmrsDlCfg->choice.setup)
7940          {
7941             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
7942             free(dmrsDlCfg->choice.setup);
7943          }
7944          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
7945       }
7946       free(dlBwp->pdsch_Config->choice.setup);
7947    }
7948 }
7949 /*******************************************************************
7950 *
7951 * @brief Function to free PuschTimeDomAllocListCfg
7952                  where the memory allocated by aper_decoder
7953 *
7954 * @details
7955 *
7956 *    Function : freeAperDecodePuschTimeDomAllocListCfg
7957 *
7958 *    Functionality: Function to free PuschTimeDomAllocListCfg
7959 *
7960 * @params[in] PUSCH_Config_t *puschCfg
7961 * @return void
7962 *
7963 * ****************************************************************/
7964
7965
7966 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
7967 {
7968    uint8_t arrIdx=0;
7969    uint8_t arrIdx1=0;
7970    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7971
7972    if(puschCfg->pusch_TimeDomainAllocationList)
7973    {
7974       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7975       if(timeDomAllocList_t->choice.setup)
7976       {
7977          if(timeDomAllocList_t->choice.setup->list.array)
7978          {
7979             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
7980             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
7981             {
7982                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
7983             }
7984             free(timeDomAllocList_t->choice.setup->list.array);
7985          }
7986          free(timeDomAllocList_t->choice.setup);
7987       }
7988       free(puschCfg->transformPrecoder);
7989       free(puschCfg->pusch_TimeDomainAllocationList);
7990    }
7991 }
7992 /*******************************************************************
7993 *
7994 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
7995 *
7996 * @details
7997 *
7998 *    Function : freeAperDecodeInitialUlBWPConfig
7999 *
8000 *    Functionality: Function to free InitialUlBWPConfig
8001 *
8002 * @params[in]  BWP_UplinkDedicated_t *ulBwp
8003 * @return void
8004 *
8005 * ****************************************************************/
8006
8007
8008 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
8009 {
8010    uint8_t  rSetIdx =0;
8011    uint8_t  rsrcIdx =0;
8012    SRS_Config_t   *srsCfg = NULLP;
8013    PUSCH_Config_t *puschCfg = NULLP;
8014    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
8015    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
8016    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
8017    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
8018
8019    if(ulBwp->pusch_Config)
8020    {
8021       if(ulBwp->pusch_Config->choice.setup)
8022       {
8023          puschCfg=ulBwp->pusch_Config->choice.setup;
8024          if(puschCfg->dataScramblingIdentityPUSCH)
8025          {
8026             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
8027             {
8028                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
8029                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
8030                if(dmrsUlCfg->choice.setup)
8031                {
8032                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
8033                   {
8034                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
8035                      {
8036                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
8037                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
8038                      }
8039                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
8040                   }
8041                   free(dmrsUlCfg->choice.setup);
8042                }
8043                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
8044             }
8045             free(puschCfg->dataScramblingIdentityPUSCH);
8046          }
8047          free(ulBwp->pusch_Config->choice.setup);
8048       }
8049       free(ulBwp->pusch_Config);
8050
8051       /* Free SRS-Config */
8052       if(ulBwp->srs_Config)
8053       {
8054          if(ulBwp->srs_Config->choice.setup)
8055          {
8056             srsCfg = ulBwp->srs_Config->choice.setup;
8057
8058             /* Free Resource Set to add/mod list */
8059             if(srsCfg->srs_ResourceSetToAddModList)
8060             {
8061                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
8062                if(rsrcSetList->list.array)
8063                {
8064                   rSetIdx = 0;
8065
8066                   /* Free SRS resource Id list in this SRS resource set */
8067                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
8068                   {
8069                      rsrcIdList =
8070                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
8071
8072                      if(rsrcIdList->list.array)
8073                      {
8074                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
8075                               rsrcIdx++)
8076                         {
8077                            free(rsrcIdList->list.array[rsrcIdx]);
8078                         }
8079                         free(rsrcIdList->list.array);
8080                      }
8081                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
8082                   }
8083
8084                   /* Free resource type info for this SRS resource set */
8085
8086                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
8087
8088                   /* Free memory for each resource set */
8089                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
8090                   {
8091                      free(rsrcSetList->list.array[rSetIdx]);
8092                   }
8093                   free(rsrcSetList->list.array);
8094                }
8095                free(srsCfg->srs_ResourceSetToAddModList);
8096             }
8097
8098             /* Free resource to add/modd list */
8099             if(srsCfg->srs_ResourceToAddModList)
8100             {
8101                resourceList = srsCfg->srs_ResourceToAddModList;
8102                if(resourceList->list.array)
8103                {
8104                   rsrcIdx = 0;
8105
8106                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
8107                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
8108
8109                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
8110                   {
8111                      free(resourceList->list.array[rsrcIdx]);
8112                   }
8113                   free(resourceList->list.array);
8114                }
8115                free(srsCfg->srs_ResourceToAddModList);
8116             }
8117
8118             free(ulBwp->srs_Config->choice.setup);
8119          }
8120          free(ulBwp->srs_Config);
8121       }
8122    }
8123 }
8124 /*******************************************************************
8125 *
8126 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
8127 *
8128 * @details
8129 *
8130 *    Function : freeAperDecodeinitialUplinkBWPConfig
8131 *
8132 *    Functionality: Function to free initialUplinkBWPConfig
8133 *
8134 * @params[in] UplinkConfig_t *ulCfg
8135 * @return void
8136 *
8137 * ****************************************************************/
8138
8139
8140 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
8141 {
8142    BWP_UplinkDedicated_t *ulBwp=NULLP;
8143    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
8144
8145    if(ulCfg->initialUplinkBWP)
8146    {
8147       ulBwp=ulCfg->initialUplinkBWP;
8148       if(ulCfg->firstActiveUplinkBWP_Id)
8149       {
8150          if(ulCfg->pusch_ServingCellConfig)
8151          {
8152             puschCfg=ulCfg->pusch_ServingCellConfig;
8153             if(puschCfg->choice.setup)
8154             {
8155                if(puschCfg->choice.setup->ext1)
8156                {
8157                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
8158                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
8159                   free(puschCfg->choice.setup->ext1);
8160                }
8161                free(puschCfg->choice.setup);
8162             }
8163             free(ulCfg->pusch_ServingCellConfig);
8164          }
8165          free(ulCfg->firstActiveUplinkBWP_Id);
8166       }
8167       freeAperDecodeInitialUlBWPConfig(ulBwp);
8168       free(ulCfg->initialUplinkBWP);
8169    }
8170 }
8171
8172 /*******************************************************************
8173  *
8174  * @brief Function to free DuUeCfg
8175  *
8176  * @details
8177  *
8178  *    Function : freeDuUeCfg
8179  *
8180  *    Functionality: Function to free DuUeCfg
8181  *
8182  * @params[in] DuUeCfg *ueCfg
8183  * @return void
8184  *
8185  * ****************************************************************/
8186 void freeDuUeCfg(DuUeCfg *ueCfg)
8187 {
8188    uint8_t lcIdx = 0;
8189    uint8_t arrIdx = 0;
8190    SpCellConfig_t *spCellCfg = NULLP;
8191    ServingCellConfig_t *srvCellCfg = NULLP;
8192    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8193    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
8194    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8195    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
8196    struct RLC_Config *rlcConfig = NULLP;
8197    struct LogicalChannelConfig *macLcConfig = NULLP;
8198    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
8199    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
8200    struct TAG_Config *tagConfig = NULLP;
8201    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
8202    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
8203    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
8204    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
8205
8206    if(ueCfg->ueNrCapability)
8207    {
8208       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
8209       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
8210       ueCfg->ueNrCapability = NULLP;
8211    }
8212
8213    if(ueCfg->cellGrpCfg)
8214    {
8215
8216       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
8217       if(rlcBearerList)
8218       {
8219          if(rlcBearerList->list.array)
8220          {
8221             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
8222             {
8223                if(rlcBearerList->list.array[arrIdx])
8224                {
8225                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
8226                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
8227
8228                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
8229                   {
8230                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
8231                   }
8232                   if(rlcConfig)
8233                   {
8234                      if(rlcConfig->choice.am)
8235                      {
8236                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
8237                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
8238                         free(rlcConfig->choice.am);
8239                      }
8240                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
8241                   }
8242                   if(macLcConfig)
8243                   {
8244                      if(macLcConfig->ul_SpecificParameters)
8245                      {
8246                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
8247                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
8248                         free(macLcConfig->ul_SpecificParameters);
8249                      }
8250                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
8251                   }
8252                   free(rlcBearerList->list.array[arrIdx]);
8253                }
8254             }
8255             free(rlcBearerList->list.array);
8256          }
8257          free(cellGrpCfg->rlc_BearerToAddModList);
8258       }
8259
8260       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
8261       if(macCellGrpCfg)
8262       {
8263          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
8264          if(schedulingRequestConfig)
8265          {
8266             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
8267             if(schReqList)
8268             {
8269                if(schReqList->list.array)
8270                {
8271                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
8272                   {
8273                      if(schReqList->list.array[arrIdx])
8274                      {
8275                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
8276                         free(schReqList->list.array[arrIdx]);
8277                      }
8278                   }
8279                   free(schReqList->list.array);
8280                }
8281                free(schedulingRequestConfig->schedulingRequestToAddModList);
8282             }
8283             free(macCellGrpCfg->schedulingRequestConfig);
8284          }
8285          if(macCellGrpCfg->bsr_Config)
8286          {
8287             free(macCellGrpCfg->bsr_Config);
8288          }
8289          tagConfig = macCellGrpCfg->tag_Config;
8290          if(tagConfig)
8291          {
8292             tagList = tagConfig->tag_ToAddModList;
8293             if(tagList)
8294             {
8295                if(tagList->list.array)
8296                {
8297                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
8298                   {
8299                      free(tagList->list.array[arrIdx]);
8300                   }
8301                   free(tagList->list.array);
8302                }
8303                free(tagConfig->tag_ToAddModList);
8304             }
8305             free(tagConfig);
8306          }
8307
8308          phrConfig = macCellGrpCfg->phr_Config;
8309          if(phrConfig)
8310          {
8311             free(phrConfig->choice.setup);
8312             free(phrConfig);
8313          }
8314
8315          free(macCellGrpCfg);
8316       }
8317
8318       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
8319       if(phyCellGrpCfg)
8320       {
8321          free(phyCellGrpCfg->p_NR_FR1);
8322          free(phyCellGrpCfg);
8323       }
8324
8325       spCellCfg = cellGrpCfg->spCellConfig;
8326       if(spCellCfg)
8327       {
8328          if(spCellCfg->servCellIndex)
8329          {
8330             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
8331             {
8332                if(spCellCfg->spCellConfigDedicated)
8333                {
8334                   srvCellCfg = spCellCfg->spCellConfigDedicated;
8335                   if(srvCellCfg->initialDownlinkBWP)
8336                   {
8337                      dlBwp = srvCellCfg->initialDownlinkBWP;
8338                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
8339                      {
8340                         if(srvCellCfg->defaultDownlinkBWP_Id)
8341                         {
8342                            if(srvCellCfg->uplinkConfig)
8343                            {
8344
8345                               if(srvCellCfg->pdsch_ServingCellConfig)
8346                               {
8347                                  pdschCfg=
8348                                     srvCellCfg->pdsch_ServingCellConfig;
8349                                  if(pdschCfg->choice.setup)
8350                                  {
8351
8352                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
8353                                     free(pdschCfg->choice.setup);
8354                                  }
8355
8356                                  free(srvCellCfg->pdsch_ServingCellConfig);
8357                               }
8358
8359                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
8360                               free(srvCellCfg->uplinkConfig);
8361                            }
8362                            free(srvCellCfg->defaultDownlinkBWP_Id);
8363                         }
8364
8365                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
8366                      }
8367                      if(dlBwp->pdcch_Config)
8368                      {
8369                         if(dlBwp->pdsch_Config)
8370                         {
8371                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
8372                            free(dlBwp->pdsch_Config);
8373                         }
8374                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
8375                         free(dlBwp->pdcch_Config);
8376                      }
8377                      free(srvCellCfg->initialDownlinkBWP);
8378                   }
8379
8380                   free(spCellCfg->spCellConfigDedicated);
8381                }
8382                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
8383             }
8384             free(spCellCfg->servCellIndex);
8385          }
8386          free(spCellCfg);
8387       }
8388       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
8389       ueCfg->cellGrpCfg = NULLP;
8390    }
8391    if(ueCfg->ambrCfg)
8392    {
8393       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
8394    }
8395    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
8396    {
8397       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
8398    }
8399    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
8400    {
8401       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
8402    }
8403    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
8404    {
8405       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
8406    }
8407 }
8408
8409 /*******************************************************************
8410  *
8411  * @brief Function to free UecontextSetupDb
8412  *
8413  * @details
8414  *
8415  *    Function : freeF1UeDb
8416  *
8417  *    Functionality: Function to free UecontextSetupDb
8418  *
8419  * @params[in] UecontextSetupDb *
8420  * @return void
8421  *
8422  * ****************************************************************/
8423
8424 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
8425 {
8426
8427    if(f1UeDb->dlRrcMsg)
8428    {
8429       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
8430       {
8431         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
8432                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
8433       }
8434       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
8435    }
8436    freeDuUeCfg(&f1UeDb->duUeCfg);
8437    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
8438    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
8439 }
8440
8441 /*******************************************************************
8442  *
8443  * @brief Function to build Am cfg Info
8444  *
8445  * @details
8446  *
8447  *    Function : extractRlcAmCfg
8448  *
8449  *    Functionality: Function to build Am cfg Info
8450  *
8451  * @params[in] AmBearerCfg *
8452  *             void *
8453  *
8454  * @return ROK/RFAILED
8455  *
8456  * ****************************************************************/
8457
8458 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
8459 {
8460    if(rlcAmCfg)
8461    {
8462       /* UL AM */
8463       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
8464       {
8465          amCfgToSet->ulAmCfg.snLenUl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->dl_AM_RLC.sn_FieldLength));
8466          /*TODO: Check the timer value when sent by real CU */
8467          amCfgToSet->ulAmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_Reassembly);
8468          amCfgToSet->ulAmCfg.statProhTmr = convertProhibitTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_StatusProhibit);
8469       }
8470
8471       /* DL AM */
8472       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
8473       {
8474          amCfgToSet->dlAmCfg.snLenDl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->ul_AM_RLC.sn_FieldLength));
8475          amCfgToSet->dlAmCfg.pollRetxTmr = covertPollRetxTmrEnumToValue(rlcAmCfg->ul_AM_RLC.t_PollRetransmit);
8476          amCfgToSet->dlAmCfg.pollPdu   = covertPollPduEnumToValue(rlcAmCfg->ul_AM_RLC.pollPDU);
8477          amCfgToSet->dlAmCfg.pollByte  = covertPollByteEnumToValue(rlcAmCfg->ul_AM_RLC.pollByte);
8478          amCfgToSet->dlAmCfg.maxRetxTh = covertMaxRetxEnumToValue(rlcAmCfg->ul_AM_RLC.maxRetxThreshold);
8479       }
8480    }
8481 }
8482
8483 /*******************************************************************
8484  *
8485  * @brief Function to build Um Bi Info
8486  *
8487  * @details
8488  *
8489  *    Function : extractRlcUmBiCfg
8490  *
8491  *    Functionality: Function to build Um Bi Info
8492  *
8493  * @params[in] UmBiDirBearerCfg *
8494  *             void *
8495  *
8496  * @return ROK/RFAILED
8497  *
8498  * ****************************************************************/
8499
8500 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
8501 {
8502    if(rlcBiCfg)
8503    {
8504       /* UL UM BI DIR Cfg */
8505       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
8506       {
8507          umBiCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->dl_UM_RLC.sn_FieldLength));
8508          umBiCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcBiCfg->dl_UM_RLC.t_Reassembly);
8509       }
8510
8511       /* DL UM BI DIR Cfg */
8512       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
8513          umBiCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->ul_UM_RLC.sn_FieldLength));
8514    }
8515 }
8516
8517 /*******************************************************************
8518  *
8519  * @brief Function to build Um Ul Info
8520  *
8521  * @details
8522  *
8523  *    Function : extractRlcUmUlCfg
8524  *
8525  *    Functionality: Function to build Um Ul Info
8526  *
8527  * @params[in] UmUniDirUlBearerCfg *
8528  *             void *
8529  *
8530  * @return ROK/RFAILED
8531  *
8532  * ****************************************************************/
8533
8534 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
8535 {
8536    if(umUlCfg)
8537    {
8538       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
8539       {
8540          umUlCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umUlCfg->dl_UM_RLC.sn_FieldLength));
8541          umUlCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(umUlCfg->dl_UM_RLC.t_Reassembly);
8542       }
8543    }
8544 }
8545
8546 /*******************************************************************
8547  *
8548  * @brief Function to build Um Uni Dl Info
8549  *
8550  * @details
8551  *
8552  *    Function : extractRlcUmDlCfg
8553  *
8554  *    Functionality: Function to build Um Uni Dl Info
8555  *
8556  * @params[in] UmUniDirDlBearerCfg *
8557  *             void *
8558  *
8559  * @return ROK/RFAILED
8560  *
8561  * ****************************************************************/
8562 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
8563 {
8564    if(umDlCfg)
8565    {
8566       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
8567          umDlCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umDlCfg->ul_UM_RLC.sn_FieldLength));
8568    }
8569 }
8570
8571 /*******************************************************************
8572  *
8573  * @brief Function to extractRlcModeCfg
8574  *
8575  * @details
8576  *
8577  *    Function : extractRlcModeCfg
8578  *
8579  *    Functionality: Function to extractRlcModeCfg
8580  *
8581  * @params[in] RLC_Config_t *
8582  *             RlcBearerCfg *
8583  *             void  *
8584  * @return ROK/RFAILED
8585  *
8586  * ****************************************************************/
8587 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
8588 {
8589    if(lcCfg)
8590    {
8591       switch(rlcMode)
8592       {
8593          case RLC_AM :
8594             {
8595                if(lcCfg->choice.am)
8596                {
8597                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
8598                   if(rlcDbCfg->u.amCfg)
8599                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
8600                }
8601                break;
8602             }
8603          case RLC_UM_BI_DIRECTIONAL :
8604             {
8605                if(lcCfg->choice.um_Bi_Directional)
8606                {
8607                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
8608                   if(rlcDbCfg->u.umBiDirCfg)
8609                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
8610                }
8611                break;
8612             }
8613          case RLC_UM_UNI_DIRECTIONAL_UL :
8614             {
8615                if(lcCfg->choice.um_Uni_Directional_DL)
8616                {
8617                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
8618                   if(rlcDbCfg->u.umUniDirUlCfg)
8619                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
8620                }
8621                break;
8622             }
8623          case RLC_UM_UNI_DIRECTIONAL_DL :
8624             {
8625                if(lcCfg->choice.um_Uni_Directional_UL)
8626                {
8627                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
8628                   if(rlcDbCfg->u.umUniDirDlCfg)
8629                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
8630                }
8631                break;
8632             }
8633          default:
8634             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
8635             break;
8636       }
8637    }
8638 }
8639
8640 /*******************************************************************
8641  *
8642  * @brief Function to extract extractUlLcCfg
8643  *
8644  * @details
8645  *
8646  *    Function : extractUlLcCfg
8647  *
8648  *    Functionality: Function to extract extractUlLcCfg
8649  *
8650  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
8651  * @return void
8652  *
8653  * ****************************************************************/
8654
8655 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
8656 {
8657    if(ulLcCfg)
8658    {
8659       if(ulLcCfg->ul_SpecificParameters)
8660       {
8661          f1UlLcCfg->priority = \
8662             ulLcCfg->ul_SpecificParameters->priority;
8663       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
8664       {
8665          f1UlLcCfg->lcGroup = \
8666            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
8667       }
8668       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
8669       {
8670          f1UlLcCfg->schReqId = \
8671            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
8672       }
8673       f1UlLcCfg->pbr = \
8674          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
8675       f1UlLcCfg->bsd = \
8676          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
8677       }
8678    }
8679 }
8680
8681 /*******************************************************************
8682 *
8683 * @brief Function to extract Snssai Cfg Info from CU
8684 *
8685 * @details
8686 *
8687 *    Function : extractDrbSnssaiCfg
8688 *
8689 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
8690 *
8691 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
8692 * @return ROK/RFAILED
8693 *
8694 * ****************************************************************/
8695
8696 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
8697 {
8698    if(!(*snssaiToBeShared))
8699    {
8700       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
8701       if(snssaiToBeShared == NULLP)
8702       {
8703          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
8704          return RFAILED;
8705       }
8706    }
8707    if(RecvSnssai)
8708    {
8709       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
8710       if(RecvSnssai->sD)
8711       {
8712          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
8713       }
8714       else
8715       {
8716          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
8717          return RFAILED;
8718       }
8719    }
8720    return ROK;
8721 }
8722
8723 /*******************************************************************
8724  *
8725  * @brief Function to procRlcLcCfg
8726  *
8727  * @details
8728  *
8729  *    Function : procRlcLcCfg
8730  *
8731  *    Functionality: Function to procRlcLcCfg
8732  *
8733  * @params[in] rbId, lcId, rbType, rlcMod
8734  *             RLC_Config_t *, RlcBearerCfg * ,
8735  * @return void
8736  *
8737  * ****************************************************************/
8738
8739 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
8740    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
8741 {
8742    DRB_Information_t *drbInfo;
8743
8744    lcCfg->rbId   = rbId;
8745    lcCfg->configType = configType;
8746
8747    if(rbType == RB_TYPE_SRB)
8748    {
8749       lcCfg->rbType = RB_TYPE_SRB;
8750       lcCfg->lcId   = rbId;
8751       lcCfg->lcType = LCH_DCCH;
8752       lcCfg->rlcMode = RLC_AM;
8753    }
8754    else if(rbType == RB_TYPE_DRB)
8755    {
8756       lcCfg->rbType = RB_TYPE_DRB;
8757       lcCfg->lcId   = lcId;
8758       lcCfg->lcType = LCH_DTCH;
8759       lcCfg->rlcMode = rlcMode;
8760    }
8761    if(f1RlcCfg) /* rlc mode config recived */
8762    {
8763       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
8764    }
8765    if(qoSInformation != NULLP)
8766    {
8767       if(qoSInformation->present == QoSInformation_PR_choice_extension)
8768       {
8769          if(qoSInformation->choice.choice_extension->value.present ==\
8770                QoSInformation_ExtIEs__value_PR_DRB_Information)
8771          {
8772             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
8773             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
8774             {
8775                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
8776                return;
8777             }
8778          }
8779       }
8780    }
8781 }
8782
8783 /*******************************************************************
8784  *
8785  * @brief Fills DrbQos Info received by CU
8786  *
8787  * @details
8788  *
8789  *    Function : extractQosInfo
8790  *
8791  *    Functionality: Fills DrbQos Info received  by CU
8792  *
8793  * @params[in] DrbQosInfo *qosToAdd,
8794  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
8795  * @return void
8796  *
8797  * ****************************************************************/
8798
8799 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
8800 {
8801    uint8_t qosCntIdx = 0;
8802    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
8803
8804    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
8805    qosToAdd->u.nonDyn5Qi.fiveQi     =\
8806                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
8807    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
8808    {
8809       qosToAdd->u.nonDyn5Qi.avgWindow = \
8810                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
8811    }
8812
8813    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume)
8814    {
8815       qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
8816                                               *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
8817    }
8818
8819    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
8820    {
8821       qosToAdd->u.nonDyn5Qi.priorLevel = \
8822                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
8823    }
8824    qosToAdd->ngRanRetPri.priorityLevel = \
8825                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
8826    qosToAdd->ngRanRetPri.preEmptionCap = \
8827                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
8828    qosToAdd->ngRanRetPri.preEmptionVul = \
8829                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
8830    if(qosFlowCfg->gBR_QoS_Flow_Information)
8831    {
8832       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
8833             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
8834             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
8835       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
8836             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
8837             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
8838       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
8839             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
8840             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
8841       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
8842             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
8843             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
8844    }
8845    /*Extracting PDU_SESSION_ID*/
8846    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
8847    if(qosIeExt)
8848    {
8849       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
8850       {
8851          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
8852                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
8853          {
8854             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
8855             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
8856          }
8857       }
8858    }
8859    qosToAdd->ulPduSessAggMaxBitRate = 0;
8860 }
8861
8862 /*******************************************************************
8863  *
8864  * @brief Function to extract GTP Tunnel Info from CU
8865  *
8866  * @details
8867  *
8868  *    Function : extractUpTnlInfo
8869  *
8870  *    Functionality: Function to extract GTP Tunnel Info from CU
8871  *
8872  * @params[in] F1AP message
8873  * @return ROK/RFAILED
8874  *
8875  * ****************************************************************/
8876
8877 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
8878    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
8879 {
8880    uint8_t tnlIdx;
8881    uint32_t ipv4_du = 0;
8882    GTPTunnel_t *gtpTunnel = NULLP;
8883
8884    upTnlInfo->drbId = drbId;
8885    upTnlInfo->configType = configType;
8886 #ifdef O1_ENABLE
8887    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
8888 #else
8889    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
8890 #endif
8891
8892    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
8893    {
8894       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
8895       {
8896          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
8897          {
8898             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
8899             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
8900             if(upTnlInfo->tnlCfg1 == NULLP)
8901             {
8902                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
8903                return RFAILED;
8904             }
8905             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
8906             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
8907             if(gtpTunnel->gTP_TEID.size > 0)
8908             {
8909                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
8910             }
8911          }
8912          break;
8913       }
8914    }
8915    return ROK;
8916 }
8917
8918 /*******************************************************************
8919 *
8920 * @brief Function to extract Drb Qos Cfg Info from CU
8921 *
8922 * @details
8923 *
8924 *    Function : extractDrbQosCfg
8925 *
8926 *    Functionality: Function to extract Drb Qos Cfg Info from CU
8927 *
8928 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
8929 * @return ROK/RFAILED
8930 *
8931 * ****************************************************************/
8932
8933 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
8934 {
8935    if(!macLcToAdd->drbQos)
8936    {
8937       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
8938       if(macLcToAdd->drbQos == NULLP)
8939       {
8940          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
8941          return RFAILED;
8942       }
8943
8944    }
8945    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
8946    {
8947       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
8948       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
8949    }
8950    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
8951    {
8952       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
8953       return RFAILED;
8954    }
8955    return ROK;
8956 }
8957 /*******************************************************************
8958  *
8959  * @brief Function to extract DRB info received from CU
8960  *
8961  * @details
8962  *
8963  *    Function : extractDrbCfg
8964  *
8965  *    Functionality: Function to extract DRB info received from CU
8966  *
8967  * @params[in] F1AP message
8968  * @return void
8969  *
8970  * ****************************************************************/
8971 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
8972 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
8973 {
8974    DRB_Information_t *drbInfo = NULLP;
8975
8976    if(drbItem != NULLP)
8977    {
8978       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
8979       {
8980          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
8981          return RFAILED;
8982       }
8983       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
8984       {
8985          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
8986          {
8987             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
8988             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
8989             {
8990                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
8991                return RFAILED;
8992             }
8993          }
8994       }
8995    }
8996    else if(drbSetupModItem != NULLP)
8997    {
8998       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
8999       upTnlInfo) != ROK)
9000       {
9001          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
9002          return RFAILED;
9003       }
9004       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
9005       {
9006          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
9007          QoSInformation_ExtIEs__value_PR_DRB_Information)
9008          {
9009             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
9010             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
9011             {
9012                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
9013                return RFAILED;
9014             }
9015
9016          }
9017       }
9018    }
9019    else if(drbModItem != NULLP)
9020    {
9021       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
9022       upTnlInfo) != ROK)
9023       {
9024          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
9025          return RFAILED;
9026       }
9027       if(drbModItem->qoSInformation != NULLP)
9028       {
9029          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
9030          {
9031             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
9032                   QoSInformation_ExtIEs__value_PR_DRB_Information)
9033             {
9034                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
9035                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
9036                {
9037                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
9038                   return RFAILED;
9039                }
9040
9041             }
9042          }
9043       }
9044    }
9045    return ROK;
9046 }
9047
9048 /*******************************************************************
9049  *
9050  * @brief Function to extract RB info received from CU
9051  *
9052  * @details
9053  *
9054  *    Function : extractMacRbCfg
9055  *
9056  *    Functionality: Function to extract RB info received from CU
9057  *
9058  * @params[in] F1AP message
9059  * @return ROK/RFAILED
9060  *
9061  * ****************************************************************/
9062
9063 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
9064 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
9065 {
9066    if(drbCfg != NULLP)
9067    {
9068       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
9069       {
9070          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
9071          return RFAILED;
9072       }
9073    }
9074    else if(drbSetupModCfg != NULLP)
9075    {
9076       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
9077       {
9078          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
9079          return RFAILED;
9080       }
9081    }
9082    else if(drbModCfg != NULLP)
9083    {
9084       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
9085       {
9086          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
9087          return RFAILED;
9088       }
9089    }
9090    else
9091    {
9092       lcCfg->drbQos = NULLP;
9093       lcCfg->snssai = NULLP;
9094       if(lcCfg->lcId == SRB2_LCID)
9095          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
9096       else
9097          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
9098    }
9099    if(ulLcCfg)
9100    {
9101       lcCfg->ulLcCfgPres = true;
9102       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
9103    }
9104    else
9105       lcCfg->ulLcCfgPres = false;
9106    return ROK;
9107 }
9108
9109 /*******************************************************************
9110  *
9111  * @brief Function processing LC config info received from CU
9112  *
9113  * @details
9114  *
9115  *    Function : procMacLcCfg
9116  *
9117  *    Functionality: Function processing LC config info received from CU
9118  *
9119  * @params[in] F1AP message
9120  * @return ROK/RFAILED
9121  *
9122  * ****************************************************************/
9123
9124 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
9125 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
9126 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
9127 {
9128    uint8_t ret = ROK;
9129
9130    lcCfg->lcId = lcId;
9131    lcCfg->configType = configType;
9132    if(rbType == RB_TYPE_SRB)
9133    {
9134       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
9135    }
9136    else if(rbType == RB_TYPE_DRB)
9137    {
9138       if(drbItem != NULL)
9139         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
9140       else if(drbSetupModItem != NULL)
9141         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
9142       else if(drbModItem != NULL)
9143         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
9144    }
9145    return ret;
9146 }
9147
9148 /*******************************************************************
9149  *
9150  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
9151  *
9152  * @details
9153  *
9154  *    Function : extractRlcCfgToAddMod
9155  *
9156  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
9157  *
9158  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
9159  *             DuUeCfg Pointer
9160  * @return ROK/RFAILED
9161  *
9162  * ****************************************************************/
9163
9164 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
9165 {
9166   uint8_t idx, rbId, lcId, rlcMode, rbType;
9167   RLC_Config_t *f1RlcCfg = NULLP;
9168   LogicalChannelConfig_t *macUlLcCfg = NULLP;
9169
9170   for(idx = 0; idx < lcCfg->list.count; idx++)
9171   {
9172      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
9173      if(lcCfg->list.array[idx]->servedRadioBearer)
9174      {
9175         /* RadioBearer for SRB/DRB */
9176         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
9177         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
9178         {
9179            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
9180            rbType = RB_TYPE_SRB;
9181         }
9182         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
9183         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
9184         {
9185            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
9186            rbType = RB_TYPE_DRB;
9187         }
9188         else
9189         {
9190            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
9191            return RFAILED;
9192         }
9193         /* MAC UL LC Config */
9194         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
9195         {
9196            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
9197         }
9198      }
9199      else
9200      {
9201         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
9202         return RFAILED;
9203      }
9204      /* RLC Mode Config */
9205      if(lcCfg->list.array[idx]->rlc_Config)
9206      {
9207         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
9208         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
9209      }
9210
9211      /* Filling RLC/MAC Config*/
9212      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
9213      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
9214      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
9215      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
9216      {
9217         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
9218         return RFAILED;
9219      }
9220      (ueCfgDb->numRlcLcs)++;
9221      (ueCfgDb->numMacLcs)++;
9222      DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
9223         rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
9224   }
9225   //TODO: To send the failure cause in UeContextSetupRsp
9226   return ROK;
9227 }
9228
9229 /*******************************************************************
9230  *
9231  * @brief DeAlloc pdsch serv cell config info
9232  *
9233  * @details
9234  *
9235  *    Function : freeMacPdschServCellInfo
9236  *
9237  *    Functionality: DeAlloc pdsch serv cell config info
9238  *
9239  * @params[in] PdschServCellCfg pointer
9240  * @return void
9241  *
9242  * ****************************************************************/
9243
9244 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
9245 {
9246    if(pdsch->xOverhead)
9247    {
9248       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
9249    }
9250    if(pdsch->codeBlkGrpFlushInd)
9251    {
9252       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
9253    }
9254    if(pdsch->maxCodeBlkGrpPerTb)
9255    {
9256       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
9257    }
9258    if(pdsch->maxMimoLayers)
9259    {
9260       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
9261    }
9262 }
9263
9264 /*******************************************************************
9265  *
9266  * @brief Free Serving cell Info
9267  *
9268  * @details
9269  *
9270  *    Function : freeMacServingCellInfo
9271  *
9272  *    Functionality: Free Serving cell Info
9273  *
9274  * @params[in] ServCellCfgInfo *srvCellCfg
9275  * @return void
9276  *
9277  * ****************************************************************/
9278 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
9279 {
9280    uint8_t timeDomRsrcIdx;
9281
9282    if(srvCellCfg->initDlBwp.pdschPresent)
9283    {
9284       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
9285       {
9286          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
9287             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
9288       }
9289    }
9290
9291    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
9292    if(srvCellCfg->bwpInactivityTmr)
9293    {
9294       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9295    }
9296
9297    if(srvCellCfg->initUlBwp.pucchPresent)
9298    {
9299       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9300    }
9301 }
9302
9303 /*******************************************************************
9304  *
9305  * @brief Free cell Grp Cfg Info
9306  *
9307  * @details
9308  *
9309  *    Function : freeUeReCfgCellGrpInfo
9310  *
9311  *    Functionality: Free cell Grp Cfg Info
9312  *
9313  * @params[in] MacUeCfg*  duUeCfg
9314  * @return void
9315  *
9316  * ****************************************************************/
9317
9318 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
9319 {
9320    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
9321 }
9322
9323 /*******************************************************************
9324  *
9325  * @brief Fills Reconfig SchReqReConfig
9326  *
9327  * @details
9328  *
9329  *    Function : extractSchReqReConfig
9330  *
9331  *    Functionality: Fills Reconfig SchReqReConfig
9332  *
9333  * @params[in] SchedulingRequestConfig_t *cuSchedReq
9334  *             SchedReqCfg*  macSchedReq
9335  * @return void
9336  *
9337  * ****************************************************************/
9338 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
9339 {
9340    uint8_t schReqIdx = 0;
9341    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
9342    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
9343
9344    if(cuSchedReq->schedulingRequestToAddModList)
9345    {
9346       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
9347       if(schReqListToAdd->list.count)
9348       {
9349          macSchedReq->addModListCount = schReqListToAdd->list.count;
9350          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
9351          {
9352             macSchedReq->addModList[schReqIdx].schedReqId = \
9353                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
9354             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
9355                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
9356             macSchedReq->addModList[schReqIdx].srTransMax    =\
9357                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
9358          }
9359       }
9360    }
9361    /* Scheduling Req To release */
9362    if(cuSchedReq->schedulingRequestToReleaseList)
9363    {
9364       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
9365       if(schReqListToRel->list.count)
9366       {
9367          macSchedReq->relListCount = schReqListToRel->list.count;
9368          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
9369          {
9370             macSchedReq->relList[schReqIdx] = \
9371                *schReqListToRel->list.array[schReqIdx];
9372          }
9373       }
9374    }
9375 }
9376
9377 /*******************************************************************
9378  *
9379  * @brief Fills TagReconfig
9380  *
9381  * @details
9382  *
9383  *    Function : extractTagReconfig
9384  *
9385  *    Functionality: Fills extractTagReconfig
9386  *
9387  * @params[in] TAG_Config_t *cuTagCfg
9388  *             TagCfg *macTagCfg
9389  * @return void
9390  *
9391  * ****************************************************************/
9392
9393 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
9394 {
9395   uint8_t tagIdx = 0;
9396   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
9397   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
9398
9399   /* Tag config to AddMod */
9400   if(cuTagCfg->tag_ToAddModList)
9401   {
9402      tagListToAddMod = cuTagCfg->tag_ToAddModList;
9403      if(tagListToAddMod->list.count)
9404      {
9405         macTagCfg->addModListCount = tagListToAddMod->list.count;
9406         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
9407         {
9408            macTagCfg->addModList[tagIdx].tagId =\
9409               tagListToAddMod->list.array[tagIdx]->tag_Id;
9410            macTagCfg->addModList[tagIdx].timeAlignTimer = \
9411
9412               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
9413         }
9414      }
9415   }
9416   /* Tag config to release */
9417   if(cuTagCfg->tag_ToReleaseList)
9418   {
9419      tagListToRel = cuTagCfg->tag_ToReleaseList;
9420      if(tagListToRel->list.count)
9421      {
9422         macTagCfg->relListCount = tagListToRel->list.count;
9423         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
9424         {
9425            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
9426         }
9427      }
9428   }
9429 }
9430
9431 /*******************************************************************
9432  *
9433  * @brief Fills PdcchCfg received by CU
9434  *
9435  * @details
9436  *
9437  *    Function : extractPdcchCfg
9438  *
9439  *    Functionality: Fills PdcchCfg received  by CU
9440  *
9441  * @params[in] PDCCH_Config_t *cuPdcchCfg,
9442  *             PdcchConfig *duPdcchCfg
9443  * @return void
9444  *
9445  * ****************************************************************/
9446
9447 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
9448 {
9449    uint8_t cRsetIdx = 0;
9450    uint8_t srchSpcIdx = 0;
9451
9452    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
9453    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
9454    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
9455    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
9456
9457
9458    /* Control Resource Set To Add/Mod List */
9459    if(cuPdcchCfg->controlResourceSetToAddModList)
9460    {
9461       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
9462       if(cRsetToAddModList->list.count)
9463       {
9464          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
9465          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
9466          {
9467             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
9468                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
9469             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
9470                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
9471             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
9472                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
9473                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
9474
9475             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
9476                 cRsetToAddModList->list.array[cRsetIdx]->duration;
9477
9478             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
9479                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
9480             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
9481             {
9482                //TODO: handle the case for Interleaved
9483             }
9484             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
9485                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
9486             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
9487             {
9488                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
9489                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
9490             }
9491          }
9492       }
9493    }
9494    /* Control Resource Set To Release List */
9495    if(cuPdcchCfg->controlResourceSetToReleaseList)
9496    {
9497       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
9498       if(cRsetToRelList->list.count)
9499       {
9500          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
9501          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
9502          {
9503             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
9504          }
9505       }
9506    }
9507
9508    /* Search space To Add/Mod List */
9509    if(cuPdcchCfg->searchSpacesToAddModList)
9510    {
9511       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
9512       if(srchSpcToAddModList->list.count)
9513       {
9514          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
9515          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
9516          {
9517             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
9518                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
9519             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
9520                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
9521             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
9522             {
9523                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
9524                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
9525             }
9526             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
9527             {
9528                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
9529                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
9530             }
9531             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
9532             {
9533                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
9534                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
9535                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
9536                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
9537                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
9538                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
9539
9540                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
9541                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
9542
9543                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
9544                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
9545             }
9546             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
9547             {
9548                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
9549                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
9550                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
9551                {
9552                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
9553                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
9554                }
9555
9556             }
9557          }
9558       }
9559    }
9560    /* Search space To Rel List */
9561    if(cuPdcchCfg->searchSpacesToReleaseList)
9562    {
9563       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
9564       if(srchSpcToRelList->list.count)
9565       {
9566          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
9567          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
9568          {
9569             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
9570                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
9571          }
9572       }
9573    }
9574 }
9575
9576 /*******************************************************************
9577  *
9578  * @brief Fills PdschCfg received by CU
9579  *
9580  * @details
9581  *
9582  *    Function : extractPdschCfg
9583  *
9584  *    Functionality: Fills PdschCfg received  by CU
9585  *
9586  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
9587  *                   which we have stored in F1UeContextSetupDb,
9588  *             PdschConfig *macPdschCfg = Used to Store the information which
9589  *                   needs to send in other layer, as well as this can be the variable
9590  *                   which stores the information in DuCb,
9591  *             PdschConfig *storedPdschCfg =  Null in case of sending the
9592  *                   information to other layer else it will have stored pdsch
9593  *                   configuration in copyOfmacUeCfg.
9594  * @return void
9595  *
9596  * ****************************************************************/
9597
9598 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
9599 {
9600    uint8_t timeDomIdx;
9601    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
9602
9603    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
9604    {
9605       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
9606             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
9607       {
9608          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
9609          {
9610             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
9611                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
9612          }
9613       }
9614    }
9615    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
9616    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
9617    {
9618       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
9619       if(timeDomAlloc->present ==\
9620             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
9621       {
9622          if(timeDomAlloc->choice.setup)
9623          {
9624             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
9625             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
9626             {
9627                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
9628                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
9629                {
9630                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
9631                   {
9632                      if(storedPdschCfg)
9633                      {
9634                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
9635                         {
9636                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
9637                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
9638                         }
9639                         else
9640                         {
9641                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
9642                         }
9643                      }
9644                      else
9645                      {
9646                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
9647                      }
9648                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
9649                      {
9650                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
9651                         return;
9652                      }
9653                   }
9654                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
9655                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
9656                }
9657                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
9658                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
9659                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
9660                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
9661             }
9662          }
9663       }
9664    }
9665    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
9666    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
9667       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
9668    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
9669    {
9670       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
9671       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
9672       {
9673          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
9674          {
9675             macPdschCfg->bundlingInfo.StaticBundling.size = \
9676                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
9677          }
9678       }
9679    }
9680    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
9681    {
9682       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
9683    }
9684
9685 }
9686
9687 /*******************************************************************
9688  *
9689  * @brief Fills PdschServingCellCfg received by CU
9690  *
9691  * @details
9692  *
9693  *    Function : extractPdschServingCellCfg
9694  *
9695  *    Functionality: Fills PdschCfg received  by CU
9696  *
9697  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
9698  *             PdschServCellCfg *macUePdschSrvCellCfg
9699  * @return ROK/RFAILED
9700  *
9701  * ****************************************************************/
9702
9703 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
9704 {
9705    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
9706    {
9707       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
9708       {
9709          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
9710          {
9711             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
9712                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
9713          }
9714          else
9715          {
9716             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
9717             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
9718             {
9719                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
9720                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
9721             }
9722             else
9723             {
9724                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
9725                return RFAILED;
9726             }
9727          }
9728          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
9729          {
9730             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
9731                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
9732          }
9733          else
9734          {
9735             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
9736             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
9737             {
9738                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
9739                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
9740             }
9741             else
9742             {
9743                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
9744                return RFAILED;
9745             }
9746          }
9747       }
9748    }
9749    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
9750    {
9751       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
9752    }
9753    if(cuPdschSrvCellCfg->ext1)
9754    {
9755       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
9756       {
9757         if(macUePdschSrvCellCfg->maxMimoLayers)
9758         {
9759            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
9760         }
9761         else
9762         {
9763            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
9764            if(macUePdschSrvCellCfg->maxMimoLayers)
9765            {
9766               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
9767            }
9768            else
9769            {
9770               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
9771               return RFAILED;
9772            }
9773         }
9774       }
9775    }
9776    if(cuPdschSrvCellCfg->xOverhead)
9777    {
9778       if(macUePdschSrvCellCfg->xOverhead)
9779       {
9780          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
9781       }
9782       else
9783       {
9784          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
9785          if(macUePdschSrvCellCfg->xOverhead)
9786          {
9787             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
9788          }
9789          else
9790          {
9791             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
9792             return RFAILED;
9793          }
9794       }
9795    }
9796    return ROK;
9797 }
9798
9799 /*******************************************************************
9800  *
9801  * @brief Fills PuschCfg received by CU
9802  *
9803  * @details
9804  *
9805  *    Function : extractPuschCfg
9806  *
9807  *    Functionality: Fills PuschCfg received  by CU
9808  *
9809  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
9810  *             PuschCfg *macPuschCfg
9811  * @return void
9812  *
9813  * ****************************************************************/
9814
9815 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
9816 {
9817    uint8_t timeDomIdx = 0;
9818    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
9819    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
9820
9821    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
9822    {
9823       if(cuPuschCfg->choice.setup)
9824       {
9825          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
9826          {
9827              macPuschCfg->dataScramblingId = \
9828                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
9829          }
9830          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
9831          {
9832             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
9833             {
9834                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
9835                {
9836                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
9837                   if(dmrsUlCfg->dmrs_AdditionalPosition)
9838                   {
9839                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
9840                         *(dmrsUlCfg->dmrs_AdditionalPosition);
9841                   }
9842                   if(dmrsUlCfg->transformPrecodingDisabled)
9843                   {
9844                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
9845                      {
9846                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
9847                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
9848                      }
9849                   }
9850                }
9851             }
9852          }
9853          /*Res Alloc Type for UL */
9854          if(cuPuschCfg->choice.setup->resourceAllocation)
9855          {
9856             macPuschCfg->resourceAllocType = \
9857                cuPuschCfg->choice.setup->resourceAllocation;
9858          }
9859          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
9860          {
9861             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
9862             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
9863             {
9864                if(timeDomAllocList->choice.setup)
9865                {
9866                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
9867                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
9868                   {
9869                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
9870                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
9871                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
9872                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
9873                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
9874                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
9875                   }
9876                }
9877             }
9878          }
9879          if(cuPuschCfg->choice.setup->transformPrecoder)
9880             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
9881       }
9882    }
9883 }
9884
9885 /*******************************************************************
9886  *
9887  * @brief Function to fill pucch Power Control
9888  *
9889  * @details
9890  *
9891  *    Function : extractPucchPowerControl
9892  *
9893  *    Functionality: Function to fill pucch Power Control
9894  *
9895  * @params[in] PucchPowerControl *pwrCtrl,
9896  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
9897  * @return void
9898  *
9899  * ****************************************************************/
9900
9901 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
9902 {
9903    uint8_t arrIdx;
9904
9905    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
9906       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
9907    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
9908       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
9909    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
9910       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
9911    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
9912       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
9913    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
9914       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
9915    if(cuPwrCtrlCfg->p0_Set)
9916    {
9917       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
9918       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
9919       {
9920          pwrCtrl->p0Set[arrIdx].p0PucchId =\
9921             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
9922          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
9923             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
9924       }
9925    }
9926    if(cuPwrCtrlCfg->pathlossReferenceRSs)
9927    {
9928       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
9929       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
9930       {
9931          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
9932             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
9933       }
9934    }
9935 }
9936
9937  /*******************************************************************
9938  *
9939  * @brief Function to extractResrcSetToAddModList sent by CU
9940  *
9941  * @details
9942  *
9943  *    Function : extractResrcSetToAddModList
9944  *
9945  *    Functionality: Fucntion to extractResrcSetToAddModList
9946  *
9947  * @params[in] PucchResrcSetCfg pointer,
9948  *             struct PUCCH_Config__resourceSetToAddModList pointer
9949  * @return void
9950  *
9951  * ****************************************************************/
9952
9953 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
9954 {
9955    uint8_t arrIdx, rsrcListIdx;
9956
9957    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
9958    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
9959    {
9960       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
9961          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
9962       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
9963          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
9964       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
9965       {
9966          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
9967             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
9968       }
9969
9970       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
9971       {
9972          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
9973             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
9974       }
9975       else
9976       {
9977          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
9978       }
9979    }
9980 }/* End of extractResrcSetToAddModList */
9981
9982 /*******************************************************************
9983  *
9984  * @brief Fills extractResrcToAddModList sent by CU
9985  *
9986  * @details
9987  *
9988  *    Function : extractResrcToAddModList
9989  *
9990  *    Functionality: Fills extractResrcToAddModList
9991  *
9992  * @params[in] PucchResrcCfg pointer,
9993  *             struct PUCCH_Config__resourceToAddModList pointer
9994  * @return ROk/RFAILED
9995  *
9996  * ****************************************************************/
9997
9998 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
9999 {
10000    uint8_t arrIdx;
10001
10002    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
10003    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
10004    {
10005       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
10006         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
10007       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
10008         cuResrcList->list.array[arrIdx]->startingPRB;
10009       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
10010       {
10011          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
10012            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
10013       }
10014       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
10015       {
10016          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
10017            *cuResrcList->list.array[arrIdx]->secondHopPRB;
10018       }
10019       /* PUCCH RSRC FORMAT */
10020       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
10021       {
10022          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
10023          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
10024          {
10025             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
10026             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
10027             {
10028                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
10029                return RFAILED;
10030             }
10031             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
10032                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
10033             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
10034                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
10035             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
10036                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
10037          }
10038       }
10039       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
10040       {
10041          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
10042          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
10043          {
10044             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
10045             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
10046             {
10047                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
10048                return RFAILED;
10049             }
10050             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
10051                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
10052             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
10053                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
10054             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
10055                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
10056             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
10057                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
10058          }
10059       }
10060       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
10061       {
10062          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
10063          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
10064          {
10065             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
10066             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
10067             {
10068                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
10069                return RFAILED;
10070             }
10071             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
10072                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
10073             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
10074                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
10075             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
10076                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
10077          }
10078       }
10079       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
10080       {
10081          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
10082          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
10083          {
10084             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
10085             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
10086             {
10087                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
10088                return RFAILED;
10089             }
10090             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
10091                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
10092             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
10093                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
10094             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
10095                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
10096          }
10097       }
10098       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
10099       {
10100          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
10101          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
10102          {
10103             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
10104             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
10105             {
10106                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
10107                return RFAILED;
10108             }
10109             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
10110                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
10111             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
10112                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
10113             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
10114                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
10115             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
10116                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
10117          }
10118       }
10119    }
10120    return ROK;
10121
10122 }/* End of extractResrcToAddModList */
10123
10124 /*******************************************************************
10125  *
10126  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
10127  *
10128  * @details
10129  *
10130  *    Function : fillPucchSchedReqPeriodAndOffset
10131  *
10132  *    Functionality: To fillPucchSchedReqPeriodAndOffset
10133  *
10134  * @params[in] macPeriodicty,
10135  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
10136  * @return void
10137  *
10138  * ****************************************************************/
10139
10140 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
10141    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
10142 {
10143    macPeriodicty = cuPeriodicty->present;
10144    switch(macPeriodicty)
10145    {
10146       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
10147          {
10148             macOffset     = cuPeriodicty->choice.sym2;
10149             break;
10150          }
10151       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
10152          {
10153             macOffset     = cuPeriodicty->choice.sym6or7;
10154             break;
10155          }
10156       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
10157          {
10158             macOffset     = cuPeriodicty->choice.sl1;
10159             break;
10160          }
10161       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
10162          {
10163             macOffset = cuPeriodicty->choice.sl2;
10164             break;
10165          }
10166       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
10167          {
10168             macOffset = cuPeriodicty->choice.sl4;
10169             break;
10170          }
10171       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
10172          {
10173             macOffset = cuPeriodicty->choice.sl5;
10174             break;
10175          }
10176       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
10177          {
10178             macOffset = cuPeriodicty->choice.sl8;
10179             break;
10180          }
10181       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
10182          {
10183             macOffset = cuPeriodicty->choice.sl10;
10184             break;
10185          }
10186       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
10187          {
10188             macOffset = cuPeriodicty->choice.sl16;
10189             break;
10190          }
10191       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
10192          {
10193             macOffset = cuPeriodicty->choice.sl20;
10194             break;
10195          }
10196       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
10197          {
10198             macOffset = cuPeriodicty->choice.sl40;
10199             break;
10200          }
10201       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
10202          {
10203             macOffset = cuPeriodicty->choice.sl80;
10204             break;
10205          }
10206       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
10207          {
10208             macOffset = cuPeriodicty->choice.sl160;
10209             break;
10210          }
10211       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
10212          {
10213             macOffset = cuPeriodicty->choice.sl320;
10214             break;
10215          }
10216       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
10217          {
10218             macOffset = cuPeriodicty->choice.sl640;
10219             break;
10220          }
10221       default :
10222          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
10223    }
10224 }
10225
10226 /*******************************************************************
10227  *
10228  * @brief Function to extractPucchFormatCfg sent by CU
10229  *
10230  * @details
10231  *
10232  *    Function : extractPucchFormatCfg
10233  *
10234  *    Functionality: Function to extractPucchFormatCfg
10235  *
10236  * @params[in] PucchFormatCfg pointer,
10237  *             PUCCH_FormatConfig_t pointer
10238  * @return void
10239  *
10240  * ****************************************************************/
10241
10242 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
10243  {
10244     if(cuFormatCfg->interslotFrequencyHopping)
10245        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
10246     if(cuFormatCfg->additionalDMRS)
10247        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
10248     if(cuFormatCfg->maxCodeRate)
10249        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
10250     if(cuFormatCfg->nrofSlots)
10251        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
10252     if(cuFormatCfg->pi2BPSK)
10253        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
10254     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
10255        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
10256  }/* End of extractPucchFormatCfg */
10257
10258 /*******************************************************************
10259  *
10260  * @brief Function to extractSchedReqCfgToAddMod sent by CU
10261  *
10262  * @details
10263  *
10264  *    Function : extractSchedReqCfgToAddMod
10265  *
10266  *    Functionality: Function to extractSchedReqCfgToAddMod
10267  *
10268  * @params[in] PucchSchedReqCfg pointer,
10269  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
10270  * @return void
10271  *
10272  * ****************************************************************/
10273
10274 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
10275 {
10276    uint8_t arrIdx;
10277
10278    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
10279    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
10280    {
10281       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
10282          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
10283       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
10284          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
10285       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
10286       {
10287          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
10288             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
10289       }
10290       if(cuSchedReqList->list.array[arrIdx]->resource)
10291       {
10292          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
10293             *cuSchedReqList->list.array[arrIdx]->resource;
10294       }
10295    }
10296
10297 }/* End of extractSchedReqCfgToAddMod */
10298
10299  /*******************************************************************
10300  *
10301  * @brief Fills PucchCfg received by CU
10302  *
10303  * @details
10304  *
10305  *    Function : extractPucchCfg
10306  *
10307  *    Functionality: Fills PucchCfg received  by CU
10308  *
10309  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
10310  *                is send by CU, which we have stored in F1UeContextSetupDb,
10311  *             PucchCfg *macPucchCfg = Used to Store the information which
10312  *                needs to send in other layer, as well as this can be the variable
10313  *                which stores the information in DuCb,
10314  *             PucchCfg *storedPucchCfg = Null in case of sending the
10315  *                information to other layer else it will have Pucch Cfg which
10316  *                we have stored in copyOfmacUeCfg.
10317  * @return ROK/RFAILED
10318  *
10319  * ****************************************************************/
10320
10321 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
10322 PucchCfg *storedPucchCfg)
10323 {
10324    uint8_t arrIdx;
10325
10326    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
10327    {
10328       if(cuPucchCfg->choice.setup)
10329       {
10330          /* Resource Set Cfg */
10331          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
10332          {
10333             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
10334             if(macPucchCfg->resrcSet == NULLP)
10335             {
10336                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
10337                return RFAILED;
10338             }
10339             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
10340             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
10341          }
10342
10343          /* Resource Cfg */
10344          if(cuPucchCfg->choice.setup->resourceToAddModList)
10345          {
10346             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
10347             if(macPucchCfg->resrc == NULLP)
10348             {
10349                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
10350                return RFAILED;
10351             }
10352             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
10353             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
10354          }
10355
10356          /* Format 1 Cfg */
10357          if(cuPucchCfg->choice.setup->format1)
10358          {
10359             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
10360             if(macPucchCfg->format1 == NULLP)
10361             {
10362                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
10363                return RFAILED;
10364             }
10365             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
10366             extractPucchFormatCfg(macPucchCfg->format1,\
10367                cuPucchCfg->choice.setup->format1->choice.setup);
10368          }
10369
10370          /* Format 2 Cfg */
10371          if(cuPucchCfg->choice.setup->format2)
10372          {
10373             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
10374             if(macPucchCfg->format2 == NULLP)
10375             {
10376                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
10377                return RFAILED;
10378             }
10379             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
10380             extractPucchFormatCfg(macPucchCfg->format2,\
10381                cuPucchCfg->choice.setup->format2->choice.setup);
10382          }
10383
10384          /* Format 3 Cfg */
10385          if(cuPucchCfg->choice.setup->format3)
10386          {
10387             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
10388             if(macPucchCfg->format3 == NULLP)
10389             {
10390                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
10391                return RFAILED;
10392             }
10393             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
10394             extractPucchFormatCfg(macPucchCfg->format3,\
10395                cuPucchCfg->choice.setup->format3->choice.setup);
10396          }
10397
10398          /* Format 4 Cfg */
10399          if(cuPucchCfg->choice.setup->format4)
10400          {
10401             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
10402             if(macPucchCfg->format4 == NULLP)
10403             {
10404                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
10405                return RFAILED;
10406             }
10407             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
10408             extractPucchFormatCfg(macPucchCfg->format4,\
10409                cuPucchCfg->choice.setup->format4->choice.setup);
10410          }
10411
10412          /* Sched Req List */
10413          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
10414          {
10415             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
10416             if(macPucchCfg->schedReq == NULLP)
10417             {
10418                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
10419                return RFAILED;
10420             }
10421             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
10422             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
10423             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
10424          }
10425
10426          /*TODO: Add support for  Spatial Info */
10427
10428          /* MultiCsiCfg */
10429          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
10430          {
10431             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
10432             if(macPucchCfg->multiCsiCfg == NULLP)
10433             {
10434                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
10435                return RFAILED;
10436             }
10437             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
10438             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
10439             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
10440             {
10441                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
10442                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
10443             }
10444          }
10445
10446          /* Dl_DataToUL_ACK */
10447          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
10448     {
10449        if(storedPucchCfg)
10450        {
10451           if(storedPucchCfg->dlDataToUlAck)
10452           {
10453              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
10454           }
10455           else
10456           {
10457             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10458           }
10459        }
10460        else
10461        {
10462           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10463        }
10464        if(macPucchCfg->dlDataToUlAck == NULLP)
10465        {
10466           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
10467           return RFAILED;
10468        }
10469        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
10470        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
10471        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
10472        {
10473           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
10474           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
10475        }
10476          }
10477
10478          /* Power Control */
10479          if(cuPucchCfg->choice.setup->pucch_PowerControl)
10480          {
10481             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
10482             if(macPucchCfg->powerControl == NULLP)
10483             {
10484                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
10485                return RFAILED;
10486             }
10487             extractPucchPowerControl(macPucchCfg->powerControl,\
10488                cuPucchCfg->choice.setup->pucch_PowerControl);
10489          }
10490       }
10491    }
10492    return ROK;
10493 }
10494
10495 /*******************************************************************
10496  *
10497  * @brief Fills ServingCellReconfig received by CU
10498  *
10499  * @details
10500  *
10501  *    Function : extractSpCellDedicatedCfg
10502  *
10503  *    Functionality: Fills ServingCellReconfig received  by CU
10504  *
10505  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
10506  *                  CU, which we have stored in F1UeContextSetupDb,
10507  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
10508  *                  which  needs to send in other layer, as well as this can be the
10509  *                  variable which stores the information in DuCb,
10510  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
10511  *                  information to other layer else it will have ServCellCfgInfo which
10512  *                  we have stored in copyOfmacUeCfg.
10513  * @return ROK/RFAILD
10514  *
10515  * ****************************************************************/
10516 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
10517 ServCellCfgInfo *storedSrvCellCfg)
10518 {
10519    uint8_t ret = ROK;
10520    BWP_DownlinkDedicated_t *dlBwp = NULLP;
10521    BWP_UplinkDedicated_t   *ulBwp = NULLP;
10522
10523    if(cuSrvCellCfg->initialDownlinkBWP)
10524    {
10525       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
10526       if(dlBwp->pdcch_Config)
10527       {
10528          if(dlBwp->pdcch_Config->choice.setup)
10529          {
10530             macSrvCellCfg->initDlBwp.pdcchPresent = true;
10531             if(storedSrvCellCfg)
10532             {
10533                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
10534                {
10535                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
10536                }
10537                else
10538                {
10539                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
10540                }
10541             }
10542             else
10543             {
10544                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
10545             }
10546          }
10547       }
10548       if(dlBwp->pdsch_Config)
10549       {
10550          if(dlBwp->pdsch_Config->choice.setup)
10551          {
10552             macSrvCellCfg->initDlBwp.pdschPresent = true;
10553
10554             if(storedSrvCellCfg)
10555             {
10556                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
10557                {
10558                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
10559                }
10560                else
10561                {
10562                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
10563                         &storedSrvCellCfg->initDlBwp.pdschCfg);
10564                }
10565             }
10566             else
10567             {
10568                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
10569             }
10570          }
10571       }
10572    }
10573    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
10574       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
10575    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
10576       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
10577    if(cuSrvCellCfg->bwp_InactivityTimer)
10578    {
10579       if(macSrvCellCfg->bwpInactivityTmr)
10580       {
10581          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
10582       }
10583       else
10584       {
10585          macSrvCellCfg->bwpInactivityTmr = NULLP;
10586          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
10587          if(macSrvCellCfg->bwpInactivityTmr)
10588          {
10589             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
10590          }
10591          else
10592          {
10593             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
10594             return RFAILED;
10595          }
10596       }
10597    }
10598    if(cuSrvCellCfg->pdsch_ServingCellConfig)
10599    {
10600       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
10601       {
10602          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
10603          if(ret == RFAILED)
10604          {
10605             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
10606             return RFAILED;
10607          }
10608       }
10609    }
10610    if(cuSrvCellCfg->uplinkConfig)
10611    {
10612       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
10613       {
10614          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
10615          if(ulBwp->pusch_Config)
10616          {
10617             macSrvCellCfg->initUlBwp.puschPresent = true;
10618             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
10619          }
10620          if(ulBwp->pucch_Config)
10621          {
10622             macSrvCellCfg->initUlBwp.pucchPresent = true;
10623             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
10624             if(storedSrvCellCfg)
10625             {
10626                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
10627                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
10628                else
10629                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
10630                   &storedSrvCellCfg->initUlBwp.pucchCfg);
10631             }
10632             else
10633             {
10634                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
10635             }
10636          }
10637       }
10638       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
10639          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
10640    }
10641    return ret;
10642 }
10643 /*******************************************************************
10644  *
10645  * @brief Fills Reconfig Cell group Info received by CU
10646  *
10647  * @details
10648  *
10649  *    Function : extractUeReCfgCellInfo
10650  *
10651  *    Functionality: Fills Reconfig Cell group Info received by CU
10652  *
10653  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
10654  *                       is send by CU, which we have stored in F1UeContextSetupDb
10655  *             MacUeCfg *MacUeCfg = Used to Store the information,
10656  *                      which needs to send in other layer, as well as this can be
10657  *                      the variable which stores the information in DuCb,
10658  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
10659  *                      information to other layer else it will have copyOfmacUeCfg
10660  *                      which we have stored in F1UeContextSetupDb.
10661  *
10662  * @return ROK/RFAILED
10663  *
10664  * ****************************************************************/
10665 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
10666 {
10667    uint8_t ret = ROK;
10668    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
10669    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
10670    SpCellConfig_t            *spcellCfg = NULLP;
10671    ServingCellConfig_t       *servCellCfg = NULLP;
10672
10673    if(cellGrp)
10674    {
10675       /* Fill MacCell Group Reconfig  */
10676       if(cellGrp->mac_CellGroupConfig)
10677       {
10678          macUeCfg->macCellGrpCfgPres = true;
10679          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
10680          if(macCellGroup->schedulingRequestConfig)
10681          {
10682             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
10683          }
10684          if(macCellGroup->tag_Config)
10685          {
10686             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
10687          }
10688          if(macCellGroup->bsr_Config)
10689          {
10690             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
10691             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
10692             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
10693             {
10694                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
10695                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
10696             }
10697          }
10698          if(macCellGroup->phr_Config)
10699          {
10700             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
10701             {
10702                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
10703                if(macCellGroup->phr_Config->choice.setup)
10704                {
10705                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
10706                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
10707                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
10708                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
10709                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
10710                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
10711                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
10712                   macCellGroup->phr_Config->choice.setup->multiplePHR;
10713                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
10714                   macCellGroup->phr_Config->choice.setup->dummy;
10715                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
10716                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
10717                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
10718                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
10719                }
10720             }
10721          }
10722       }
10723       /* Fill Physical Cell Group Reconfig */
10724       if(cellGrp->physicalCellGroupConfig)
10725       {
10726          macUeCfg->phyCellGrpCfgPres = true;
10727          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
10728          if(phyCellGrpCfg->p_NR_FR1)
10729          {
10730             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
10731                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
10732          }
10733          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
10734       }
10735       /* Fill SpCell Reconfig */
10736       if(cellGrp->spCellConfig)
10737       {
10738          macUeCfg->spCellCfgPres = true;
10739          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
10740          if(spcellCfg->servCellIndex)
10741          {
10742             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
10743          }
10744          /* Fill Serving cell Reconfig info */
10745          if(cellGrp->spCellConfig->spCellConfigDedicated)
10746          {
10747             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
10748             if(storedMacUeCfg)
10749             {
10750                if(!storedMacUeCfg->spCellCfgPres)
10751                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
10752                else
10753                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
10754                         &storedMacUeCfg->spCellCfg.servCellCfg);
10755             }
10756             else
10757             {
10758                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
10759             }
10760             if(ret == RFAILED)
10761             {
10762                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
10763             }
10764          }
10765       }
10766    }
10767    return ret;
10768 }
10769 /*******************************************************************
10770 *
10771 * @brief free the memory allocated by decoder
10772 *
10773 * @details
10774 *
10775 *    Function : freeAperDecodeNrcgi
10776 *
10777 *    Functionality: Free Nrcgi values
10778 *
10779 * @params[in] NRCGI_t *nrcgi
10780 * @return void
10781 *
10782 * ****************************************************************/
10783
10784
10785 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
10786 {
10787     if(nrcgi->pLMN_Identity.buf != NULLP)
10788     {
10789        free(nrcgi->pLMN_Identity.buf);
10790     }
10791     if(nrcgi->nRCellIdentity.buf != NULLP)
10792     {
10793        free(nrcgi->nRCellIdentity.buf);
10794     }
10795 }
10796 /*******************************************************************
10797 *
10798 * @brief free the memory allocated by decoder
10799 *
10800 * @details
10801 *
10802 *    Function : freeAperDecodeCuToDuInfo
10803 *
10804 *    Functionality:  Free Cu To Du Information
10805 *
10806 * @params[in] CUtoDURRCInformation_t *rrcMsg
10807 * @return void
10808 *
10809 * ****************************************************************/
10810
10811
10812 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
10813 {
10814    uint8_t ieIdx =0;
10815    uint8_t arrIdx =0;
10816
10817    if(rrcMsg->uE_CapabilityRAT_ContainerList)
10818    {
10819       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
10820          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
10821       free(rrcMsg->uE_CapabilityRAT_ContainerList);
10822    }
10823
10824    if(rrcMsg->iE_Extensions)
10825    {
10826       if(rrcMsg->iE_Extensions->list.array)
10827       {
10828          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
10829          {
10830             if(rrcMsg->iE_Extensions->list.array[ieIdx])
10831             {
10832                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
10833                {
10834                   case ProtocolIE_ID_id_CellGroupConfig:
10835                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
10836                      {
10837                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
10838                      }
10839                      break;
10840                   default:
10841                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
10842                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
10843                      break;
10844                }
10845             }
10846          }
10847          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
10848          {
10849             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
10850          }
10851          free(rrcMsg->iE_Extensions->list.array);
10852
10853       }
10854
10855       free(rrcMsg->iE_Extensions);
10856    }
10857 }
10858 /*******************************************************************
10859 *
10860 * @brief free the memory allocated by decoder
10861 *
10862 * @details
10863 *
10864 *    Function : freeAperDecodeSplCellList
10865 *
10866 *    Functionality: Free Spl Cell List
10867                     where memory allocated by aper_decoder
10868 *
10869 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
10870 * @return void
10871 *
10872 * ****************************************************************/
10873
10874
10875 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
10876 {
10877     uint8_t  cellIdx =0;
10878
10879     if(spCellLst->list.array != NULLP)
10880     {
10881        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
10882        {
10883           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
10884           {
10885              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
10886           }
10887           if(spCellLst->list.array[cellIdx]!=NULLP)
10888           {
10889              free(spCellLst->list.array[cellIdx]);
10890           }
10891        }
10892        free(spCellLst->list.array);
10893     }
10894 }
10895 /*******************************************************************
10896 *
10897 * @brief free the memory allocated by decoder
10898 *
10899 * @details
10900 *
10901 *    Function : freeAperDecodeSRBSetup
10902 *
10903 *    Functionality: added free part for the memory allocated by aper_decoder
10904 *
10905 * @params[in] SRBs_ToBeSetup_List_t *srbSet
10906 * @return void
10907 *
10908 ****************************************************************/
10909
10910
10911 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
10912 {
10913     uint8_t srbIdx =0;
10914     if(srbSet->list.array != NULLP)
10915     {
10916        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
10917        {
10918           if(srbSet->list.array[srbIdx]!=NULLP)
10919           {
10920              free(srbSet->list.array[srbIdx]);
10921           }
10922        }
10923        free(srbSet->list.array);
10924     }
10925 }
10926
10927 /*******************************************************************
10928 *
10929 * @brief free the memory allocated by decoder
10930 *
10931 * @details
10932 *
10933 *    Function : freeAperDecodeULTnlInfo
10934 *
10935 *    Functionality: added free part for the memory allocated by aper_decoder
10936 *
10937 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10938 * @return void
10939 *
10940 * ****************************************************************/
10941
10942
10943 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
10944 {
10945    uint8_t ulIdx=0;
10946    if(ulInfo->list.array != NULLP)
10947    {
10948       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
10949       {
10950          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
10951          {
10952             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
10953             {
10954                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10955                      transportLayerAddress.buf != NULLP)
10956                {
10957                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10958                         !=NULLP)
10959                   {
10960                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
10961                   }
10962                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10963                         transportLayerAddress.buf);
10964                }
10965                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
10966             }
10967          }
10968          if(ulInfo->list.array[ulIdx]!=NULLP)
10969          {
10970             free(ulInfo->list.array[ulIdx]);
10971          }
10972       }
10973       free(ulInfo->list.array);
10974    }
10975 }
10976 /*******************************************************************
10977 *
10978 * @brief free the memory allocated by decoder
10979 *
10980 * @details
10981 *
10982 *    Function : freeAperDecodeDRBSetup
10983 *
10984 *    Functionality: free DRBSetup which is allocated by decoder
10985 *
10986 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
10987 * @return void
10988 *
10989 * ****************************************************************/
10990
10991 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
10992 {
10993    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
10994    uint8_t  flowIdx =0;
10995    uint8_t  drbIdx =0;
10996
10997    if(drbSet->list.array != NULLP)
10998    {
10999       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
11000       {
11001          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
11002          {
11003             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
11004             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
11005             {
11006                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11007                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
11008                {
11009                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11010                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
11011                   {
11012                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11013                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11014                      {
11015
11016                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
11017                         {
11018
11019                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
11020                            {
11021
11022                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
11023                                     buf!=NULLP)
11024                               {
11025
11026                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
11027                                        flows_Mapped_To_DRB_List.list.array != NULLP)
11028                                  {
11029
11030                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11031                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
11032                                     {
11033
11034                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11035                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
11036                                        {
11037                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11038                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11039                                                 qoSFlowLevelQoSParameters.\
11040                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
11041                                           {
11042                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11043                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11044                                                    qoSFlowLevelQoSParameters.\
11045                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
11046                                              {
11047
11048                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11049                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11050                                                       qoSFlowLevelQoSParameters.\
11051                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11052                                                 {
11053
11054
11055                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11056                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11057                                                          qoSFlowLevelQoSParameters.\
11058                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11059                                                 }
11060
11061                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11062                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11063                                                       qoSFlowLevelQoSParameters.\
11064                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11065                                              }
11066
11067                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11068
11069                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11070                                                    qoSFlowLevelQoSParameters.\
11071                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
11072                                           }
11073                                        }
11074                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11075                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
11076                                        {
11077
11078                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11079                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
11080                                        }
11081                                     }
11082
11083                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11084                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
11085                                  }
11086
11087                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11088                                        DRB_Information.sNSSAI.sD->buf);
11089                               }
11090
11091                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
11092                            }
11093
11094                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
11095
11096                         }
11097
11098                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11099
11100                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11101                      }
11102
11103                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11104                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11105                   }
11106
11107                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11108                         qoS_Characteristics.choice.non_Dynamic_5QI);
11109                }
11110                free(drbSetItem->qoSInformation.choice.choice_extension);
11111             }
11112             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
11113             if(drbSetItem->uLConfiguration)
11114             {
11115                free(drbSetItem->uLConfiguration);
11116             }
11117          }
11118          if(drbSet->list.array[drbIdx]!=NULLP)
11119          {
11120             free(drbSet->list.array[drbIdx]);
11121          }
11122       }
11123       free(drbSet->list.array);
11124    }
11125 }
11126
11127
11128 /*******************************************************************
11129  *
11130  * @brief builds Mac Cell Cfg
11131  *
11132  * @details
11133  *
11134  *    Function : procUeReCfgCellInfo
11135  *
11136  *    Functionality: builds Mac Cell Cfg
11137  *
11138  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
11139  *                       needs to send in other layer, as well as this can be
11140  *                       the variable which stores the information in DuCb.
11141  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
11142  *                       information to other layer else it will have copyOfmacUeCfg
11143  *                       which we have stored in F1UeContextSetupDb
11144  *             void *cellInfo = CellGroupConfigRrc_t information which is send
11145  *                        by CU, which we have stored in F1UeContextSetupDb
11146  *
11147  * @return void
11148  *
11149  * ****************************************************************/
11150 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend, MacUeCfg *storedMacUeCfg, void *cellInfo)
11151 {
11152    uint8_t ret = ROK;
11153    CellGroupConfigRrc_t *cellGrp = NULLP;
11154
11155    if(cellInfo)
11156    {
11157       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
11158       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
11159       if(ret == RFAILED)
11160          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
11161    }
11162    if(ret == RFAILED)
11163    {
11164       freeUeReCfgCellGrpInfo(macUeCfgToSend);
11165    }
11166    return ret;
11167 }
11168
11169 /*******************************************************************
11170  *
11171  * @brief Filling modulation info in mac ue cfg
11172  *
11173  * @details
11174  *
11175  *    Function : duFillModulationDetails
11176  *
11177  *    Functionality: Filling modulation info in mac ue cfg
11178  *
11179  * @params[in] MAC UE Config to be updated
11180  *             Current UE configuration
11181  *             UE NR capability from CU
11182  * @return ROK     - success
11183  *         RFAILED - failure
11184  *
11185  * ****************************************************************/
11186 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
11187 {
11188    UE_NR_Capability_t *ueNrCap=NULLP;
11189
11190    if(!ueCap && oldUeCfg)
11191    {
11192       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
11193       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
11194    }
11195    else
11196    {
11197       ueNrCap = (UE_NR_Capability_t *)ueCap;
11198
11199       /* Filling DL modulation info */
11200       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
11201          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
11202          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
11203       {
11204          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
11205          {
11206             case ModulationOrder_qpsk:
11207                {
11208                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
11209                   break;
11210                }
11211             case ModulationOrder_qam16:
11212                {
11213                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
11214                   break;
11215                }
11216             case ModulationOrder_qam64:
11217                {
11218                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
11219                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
11220                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
11221                   break;
11222                }
11223             case ModulationOrder_qam256:
11224                {
11225                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
11226                   break;
11227                }
11228             default:
11229                {
11230                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
11231                   if(oldUeCfg)
11232                      memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
11233                   break;
11234                }
11235          }
11236       }
11237       else
11238       {
11239          if(oldUeCfg)
11240             memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
11241       }
11242
11243       /* Filling UL modulation info */
11244       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
11245          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
11246          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
11247       {
11248          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
11249          {
11250             case ModulationOrder_qpsk:
11251                {
11252                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
11253                   break;
11254                }
11255             case ModulationOrder_qam16:
11256                {
11257                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
11258                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
11259                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
11260                   break;
11261                }
11262             case ModulationOrder_qam64:
11263                {
11264                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
11265                   break;
11266                }
11267             case ModulationOrder_qam256:
11268                {
11269                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
11270                   break;
11271                }
11272             default:
11273                {
11274                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
11275                   if(oldUeCfg)
11276                      memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
11277                   break;
11278                }
11279          }
11280       }
11281       else
11282       {
11283          if(oldUeCfg)
11284             memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
11285       }
11286    }
11287 }
11288
11289 /*******************************************************************
11290  *
11291  * @brief Function to extract info from CU to DU RRC container extension
11292  *
11293  * @details
11294  *
11295  *    Function : extractCuToDuRrcInfoExt
11296  *
11297  *    Functionality: Function to extract info from CU to DU RRC container
11298  *    extension
11299  *
11300  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
11301  *
11302  * @return ROK
11303  *         RFAILED
11304  *
11305  * ****************************************************************/
11306 uint8_t extractCuToDuRrcInfoExt(ProtocolExtensionContainer_4624P16_t *protocolIeExtn, DuUeCfg *ueCfgDb)
11307 {
11308    uint8_t ieIdx =0;
11309    uint16_t recvBufLen =0;
11310    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
11311    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
11312    asn_dec_rval_t rval; /* Decoder return value */
11313    memset(&rval, 0, sizeof(asn_dec_rval_t));
11314
11315    if(protocolIeExtn)
11316    {
11317       for(ieIdx = 0; ieIdx < protocolIeExtn->list.count; ieIdx++)
11318       {
11319          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[ieIdx]));
11320          switch(extIeInfo->id)
11321          {
11322             case ProtocolIE_ID_id_CellGroupConfig:
11323                {
11324                   /* decoding the CellGroup Buf received */
11325                   recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
11326                   DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
11327                   if(cellGrpCfg)
11328                   {
11329                      memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
11330                      rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
11331                            extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
11332                      if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11333                      {
11334                         DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
11335                         return RFAILED;
11336                      }
11337                      xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
11338
11339                      if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
11340                         return NULLP;
11341                      ueCfgDb->cellGrpCfg = cellGrpCfg;
11342                   }
11343                   break;
11344                }
11345
11346             case ProtocolIE_ID_id_HandoverPreparationInformation:
11347                {
11348                   DU_LOG("\nINFO -->  F1AP : Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
11349                   break;
11350                }
11351
11352             default:
11353                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation: %ld at decodeCellGrpCfg()", extIeInfo->id);
11354                break;
11355          }
11356       }
11357    }
11358    return ROK;
11359 }
11360
11361 /*******************************************************************
11362  *
11363  * @brief Fills Srb List received by CU
11364  *
11365  * @details
11366  *
11367  *    Function : procSrbListToSetup
11368  *
11369  *    Functionality: Fills Srb List received  by CU
11370  *
11371  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
11372  *             LcCfg pointer
11373  *             RlcBearerCfg pointer
11374  * @return void
11375  *
11376  * ****************************************************************/
11377 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
11378 {
11379
11380    /* Filling RLC INFO */
11381    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
11382
11383    /* Filling MAC INFO */
11384    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
11385    {
11386       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
11387       return RFAILED;
11388    }
11389
11390    return ROK;
11391 }
11392
11393
11394
11395 /*******************************************************************
11396  *
11397  * @brief extract Srb List received by CU
11398  *
11399  * @details
11400  *
11401  *    Function : extractSrbListToSetup
11402  *
11403  *    Functionality: extract Srb List received by CU
11404  *                   for both MAC and RLC
11405  *
11406  * @params[in] SRBs_ToBeSetup_Item_t pointer
11407  *             DuUeCfg pointer
11408  * @return ROK/RFAIED
11409  *
11410  * ****************************************************************/
11411
11412 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
11413 {
11414    uint8_t ret = ROK, srbIdx = 0, rlcLcIdx = 0;
11415    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
11416    LcCfg *macLcCtxt = NULLP;
11417    RlcBearerCfg *rlcLcCtxt = NULLP;
11418
11419    if(srbCfg)
11420    {
11421       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
11422       {
11423          macLcCtxt = NULL;
11424          rlcLcCtxt = NULL;
11425
11426          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
11427          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
11428          {
11429             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
11430             ret = RFAILED;
11431             break;
11432          }
11433          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
11434          {
11435             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
11436             ret = RFAILED;
11437             break;
11438          }
11439
11440          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numMacLcs; rlcLcIdx++)
11441          {
11442             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == srbItem->sRBID && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_SRB)
11443             {
11444                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
11445                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
11446                break;
11447             }
11448          }
11449          if(!macLcCtxt)
11450          {
11451             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
11452             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
11453             ueCfgDb->numMacLcs++;
11454          }
11455          if(!rlcLcCtxt)
11456          {
11457             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
11458             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
11459             ueCfgDb->numRlcLcs++;
11460          }
11461
11462          ret = procSrbListToSetup(srbItem, macLcCtxt, rlcLcCtxt);
11463
11464          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
11465                srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
11466          if(ret == RFAILED)
11467          {
11468             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
11469             break;
11470          }
11471       }
11472    }
11473    else
11474       ret = RFAILED;
11475
11476    return ret;
11477 }
11478
11479 /*******************************************************************
11480  *
11481  * @brief Fills Drb List received by CU
11482  *
11483  * @details
11484  *
11485  *    Function : procDrbListToSetupMod
11486  *
11487  *    Functionality: Fills Drb List received by CU
11488  *                   for both MAC and RLC
11489  *
11490  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
11491  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
11492  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
11493  * @return void
11494  *
11495  * ****************************************************************/
11496
11497 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
11498 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
11499 {
11500    uint8_t cfgIdx = 0;
11501    RlcMode rlcModeInfo;
11502
11503    if(drbItem != NULLP)
11504    {
11505       /* Filling RLC INFO */
11506       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
11507       qoSInformation);
11508
11509       /* Filling MAC INFO */
11510       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
11511       {
11512          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
11513          return RFAILED;
11514       }
11515    }
11516    else if(drbSetupModItem != NULLP)
11517    {
11518       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
11519       &drbSetupModItem->qoSInformation);
11520
11521       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
11522       {
11523          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
11524          return RFAILED;
11525       }
11526    }
11527    else if(drbModItem != NULLP)
11528    {
11529       /* Drb to Mod IEs doesnot have rlcMode to be modified
11530        * in ASN. Hence no change in RLC configurations */
11531       if(storedRlcUeCfg != NULLP)
11532       {
11533          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
11534          {
11535             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
11536             {
11537                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
11538                break;
11539             }
11540          }
11541       }
11542
11543       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
11544       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
11545       {
11546          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
11547          return RFAILED;
11548       }
11549    }
11550    return ROK;
11551 }
11552
11553 /*******************************************************************
11554  *
11555  * @brief extract Drb List received by CU
11556  *
11557  * @details
11558  *
11559  *    Function : extractDrbListToSetupMod
11560  *
11561  *    Functionality: extract Drb List received by CU
11562  *                   for both MAC and RLC
11563  *
11564  * @params[in] DRBs_ToBeSetup_Item_t pointer
11565  *             DuUeCfg pointer
11566  * @return ROK/RFAIED
11567  *
11568  * ****************************************************************/
11569
11570 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
11571  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
11572 {
11573    uint8_t ret = ROK;
11574    uint8_t drbIdx = 0, rlcLcIdx = 0;
11575    uint8_t drbId = 0, lcId = 0;
11576    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
11577    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
11578    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
11579    LcCfg *macLcCtxt = NULLP;
11580    RlcBearerCfg *rlcLcCtxt = NULLP;
11581
11582    ret = ROK;
11583    if(drbCount > 0)
11584    {
11585       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
11586       {
11587          macLcCtxt = NULL;
11588          rlcLcCtxt = NULL;
11589
11590          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
11591          {
11592             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
11593             ret = RFAILED;
11594             break;
11595          }
11596          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
11597          {
11598             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
11599             ret = RFAILED;
11600             break;
11601          }
11602
11603          if(drbModCfg != NULLP)
11604          {
11605             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
11606             drbId = drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID;
11607          }
11608          else if(drbCfg != NULLP)
11609             drbId = drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item.dRBID;
11610          else if(drbSetupModCfg != NULL)
11611          {
11612             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
11613             drbId = drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item.dRBID;
11614          }
11615
11616          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numRlcLcs; rlcLcIdx++)
11617          {
11618             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == drbId && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_DRB)
11619             {
11620                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
11621                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
11622                break;
11623             }
11624          }
11625          if(!macLcCtxt)
11626          {
11627             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
11628             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
11629             ueCfgDb->numMacLcs++;
11630          }
11631          if(!rlcLcCtxt)
11632          {
11633             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
11634             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
11635             ueCfgDb->numRlcLcs++;
11636          }
11637
11638          if(drbModCfg != NULLP)
11639          {
11640             lcId = fetchLcId(drbId);
11641             if(lcId < MIN_DRB_LCID)
11642             {
11643                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
11644                break;
11645             }
11646             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
11647             macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
11648             if(ret == RFAILED)
11649             {
11650                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
11651                break;
11652             }
11653          }
11654          else
11655          {
11656             lcId = getDrbLcId(drbBitMap);
11657             if(lcId == RFAILED)
11658             {
11659                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
11660                ret = RFAILED;
11661                break;
11662             }
11663             if(drbCfg != NULL)
11664             {
11665                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
11666                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
11667                if(ret == RFAILED)
11668                {
11669                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
11670                   break;
11671                }
11672             }
11673             else if(drbSetupModCfg != NULL)
11674             {
11675                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
11676                      macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
11677                if(ret == RFAILED)
11678                {
11679                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
11680                   break;
11681                }
11682                ueCfgDb->numDrbSetupMod++;
11683             }
11684          }
11685          ueCfgDb->numDrb++;
11686
11687          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
11688                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
11689          if(ret == RFAILED)
11690          {
11691             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
11692             break;
11693          }
11694       }
11695    }
11696    else
11697       ret = RFAILED;
11698
11699    return ret;
11700 }
11701
11702 /*******************************************************************
11703  *
11704  * @brief Function to extract Dl RRC Msg received from CU
11705  *
11706  * @details
11707  *
11708  *    Function : extractDlRrcMsg
11709  *
11710  *    Functionality: Function to extract Dl RRC Msg received from CU
11711  *
11712  * @params[in] F1AP message
11713  * @return ROK     - success
11714  *         RFAILED - failure
11715  *
11716  * ****************************************************************/
11717
11718 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
11719    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
11720 {
11721    uint8_t ret = ROK;
11722    dlRrcMsg->rrcMsgSize = rrcContainer->size;
11723    if(dlRrcMsg->rrcMsgSize > 0)
11724    {
11725       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
11726       if(!dlRrcMsg->rrcMsgPdu)
11727       {
11728          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
11729          ret = RFAILED;
11730       }
11731       else
11732       {
11733          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
11734          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
11735          dlRrcMsg->srbId = SRB1_LCID;
11736          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
11737       }
11738    }
11739    return ret;
11740 }
11741
11742 /*******************************************************************
11743  *
11744  * @brief Extract UE capability info
11745  *
11746  * @details
11747  *
11748  *    Function : extractUeCapability
11749  *
11750  *    Functionality: Extract UE capability info and stores in ue Cb
11751  *
11752  * @params[in] Octet string of UE capability RAT container list
11753  * @return ROK     - success
11754  *         RFAILED - failure
11755  *
11756  * ****************************************************************/
11757 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
11758 {
11759    uint8_t  idx;
11760    uint16_t recvBufLen;
11761    asn_dec_rval_t rval;
11762    UE_NR_Capability_t  *ueNrCap = NULLP;
11763    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
11764
11765    /* Decoding UE Capability RAT Container List */
11766    recvBufLen = ueCapablityListBuf->size;
11767    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11768    if(!ueCapRatContList)
11769    {
11770       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
11771       return NULLP;
11772    }
11773    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11774    memset(&rval, 0, sizeof(asn_dec_rval_t));
11775    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
11776           ueCapablityListBuf->buf, recvBufLen, 0, 0);
11777    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11778    {
11779       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
11780       return NULLP;
11781    }
11782    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
11783
11784    /* Free encoded buffer after decoding */
11785
11786    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
11787    {
11788       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
11789       {
11790          /* Decoding UE NR Capability */
11791           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
11792           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
11793           if(!ueNrCap)
11794           {
11795              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
11796              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11797              return NULLP;
11798           }
11799           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
11800           memset(&rval, 0, sizeof(asn_dec_rval_t));
11801           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
11802                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
11803           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11804           {
11805              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
11806              return NULLP;
11807           }
11808           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
11809
11810           /* Free encoded buffer after decoding */
11811           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
11812       }
11813       free(ueCapRatContList->list.array[idx]);
11814    }
11815
11816    /* Free Memory*/
11817    free(ueCapRatContList->list.array);
11818    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11819    return ueNrCap;
11820 }
11821
11822 /*******************************************************************
11823 *
11824 * @brief free UE context setup request from CU
11825 *
11826 * @details
11827 *
11828 *    Function : freeAperDecodeF1UeContextSetupReq
11829 *
11830 *    Functionality: freeing part for the memory allocated by aper_decoder
11831 *
11832 * @params[in] F1AP message
11833 * @return ROK     - success
11834 *         RFAILED - failure
11835 *
11836 * ****************************************************************/
11837 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
11838 {
11839    uint8_t ieIdx = 0;
11840
11841    if(ueSetReq->protocolIEs.list.array != NULLP)
11842    {
11843       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
11844       {
11845          if(ueSetReq->protocolIEs.list.array[ieIdx])
11846          {
11847             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
11848             {
11849                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11850                   break;
11851                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11852                   break;
11853                case ProtocolIE_ID_id_SpCell_ID:
11854                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
11855                   break;
11856                case ProtocolIE_ID_id_ServCellIndex:
11857                   break;
11858                case ProtocolIE_ID_id_SpCellULConfigured:
11859                   break;
11860                case ProtocolIE_ID_id_CUtoDURRCInformation:
11861
11862                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
11863                   break;
11864                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
11865
11866                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
11867                   break;
11868                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
11869
11870                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
11871                   break;
11872                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
11873
11874                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
11875                   break;
11876                case ProtocolIE_ID_id_RRCContainer:
11877                   {
11878
11879                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
11880                      {
11881
11882                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
11883                      }
11884                      break;
11885                   }
11886                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11887                   break;
11888                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
11889                   {
11890                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
11891                      {
11892                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
11893                      }
11894                      break;
11895                   }
11896                default:
11897                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
11898             }
11899             free(ueSetReq->protocolIEs.list.array[ieIdx]);
11900          }
11901       }
11902       free(ueSetReq->protocolIEs.list.array);
11903    }
11904 }
11905 /*******************************************************************
11906  *
11907  * @brief Process UE context setup request from CU
11908  *
11909  * @details
11910  *
11911  *    Function : procF1UeContextSetupReq
11912  *
11913  *    Functionality: Process UE context setup request from CU
11914  *
11915  * @params[in] F1AP message
11916  * @return ROK     - success
11917  *         RFAILED - failure
11918  *
11919  * ****************************************************************/
11920 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
11921 {
11922    int8_t ueIdx = -1;
11923    uint8_t  ret=0, ieIdx=0, ieExtIdx = 0, servCellIdx = 0;
11924    bool ueCbFound = false, hoInProgress = false;
11925    uint16_t nrCellId = 0,  cellIdx=0;
11926    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
11927    DuUeCb   *duUeCb = NULL;
11928    UEContextSetupRequest_t   *ueSetReq = NULL;
11929    DRBs_ToBeSetup_List_t *drbCfg = NULL;
11930    CUtoDURRCInformation_t *rrcInfo = NULL;
11931
11932    ret = ROK;
11933
11934    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
11935    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
11936    {
11937       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
11938       {
11939          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11940             {
11941                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11942                break;
11943             }
11944
11945          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11946             {
11947                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11948                break;
11949             }
11950
11951          case ProtocolIE_ID_id_SpCell_ID:
11952             {
11953                bitStringToInt(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
11954
11955                GET_CELL_IDX(nrCellId, cellIdx);
11956                if(!duCb.actvCellLst[cellIdx])
11957                {
11958                   DU_LOG("\nERROR  -->  F1AP : Cell Id [%d] not found", nrCellId);
11959                   ret = RFAILED;
11960                }
11961                break;
11962             }
11963
11964          case ProtocolIE_ID_id_ServCellIndex:
11965             {
11966                servCellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
11967                break;
11968             }
11969
11970          case ProtocolIE_ID_id_SpCellULConfigured:
11971             {
11972                /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
11973                   UL, SUL or UL+SUL for the indicated cell for the UE */
11974                break;
11975             }
11976
11977          case ProtocolIE_ID_id_CUtoDURRCInformation:
11978             {
11979                rrcInfo = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation;
11980
11981                /* Search if UE context is present */
11982                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11983                {
11984                   if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId)
11985                   {
11986                      ueCbFound = true;
11987                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
11988                      break;
11989                   }
11990                }
11991
11992                /* Check if UE Handover scenario */
11993                if(rrcInfo->iE_Extensions)
11994                {
11995                   for(ieExtIdx = 0; ieExtIdx < rrcInfo->iE_Extensions->list.count; ieExtIdx++)
11996                   {
11997                      if(rrcInfo->iE_Extensions->list.array[ieExtIdx]->id == ProtocolIE_ID_id_HandoverPreparationInformation)
11998                      {
11999                         hoInProgress = true;
12000                         break;
12001                      }
12002                   }
12003                }
12004
12005                /* If UE context is not present, but UE is in handover */
12006                if(!ueCbFound && hoInProgress)
12007                {
12008                   ueIdx = getFreeBitFromUeBitMap(nrCellId);
12009                   if(ueIdx != -1)
12010                      gnbDuUeF1apId = ueIdx +1;
12011                   else
12012                   {
12013                      DU_LOG("\nERROR  -->  F1AP : No free UE IDX found in UE bit map of cell Id [%d]", nrCellId);
12014                      ret = RFAILED;
12015                      break;
12016                   }
12017                   duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12018                   duUeCb->f1UeDb = NULL;
12019                   duUeCb->gnbCuUeF1apId = gnbCuUeF1apId;
12020                   duUeCb->gnbDuUeF1apId = gnbDuUeF1apId;
12021                   GET_CRNTI(duUeCb->crnti, duUeCb->gnbDuUeF1apId);
12022                   duUeCb->ueState = UE_HANDIN_IN_PROGRESS;
12023                }
12024
12025                if(duUeCb)
12026                {
12027                   DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12028                   if(duUeCb->f1UeDb)
12029                   {
12030                      memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
12031                      duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
12032                      duUeCb->f1UeDb->cellIdx = cellIdx;
12033                   }
12034                   else
12035                   {
12036                      DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
12037                      ret = RFAILED;
12038                      break;
12039                   }
12040                }
12041                else
12042                {
12043                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
12044                   ret = RFAILED;
12045                   break;
12046                }
12047
12048                /* Extract UE capability info */
12049                if(rrcInfo->uE_CapabilityRAT_ContainerList)
12050                {
12051                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = extractUeCapability(rrcInfo->uE_CapabilityRAT_ContainerList, duUeCb);
12052                }
12053
12054                /* Extract IE extension */
12055                if(rrcInfo->iE_Extensions)
12056                {
12057                   if(extractCuToDuRrcInfoExt(rrcInfo->iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
12058                   {
12059                      DU_LOG("\nERROR  -->  F1AP: Failed to extract CU to DU RRC information extension IE");
12060                      //TODO: Update the failure cause in ue context Setup Response
12061                      ret = RFAILED;
12062                   }
12063                }
12064                break;
12065             }
12066
12067          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
12068             {
12069                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
12070                break;
12071             }
12072
12073          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
12074             {
12075                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
12076                         &duUeCb->f1UeDb->duUeCfg))
12077                {
12078                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
12079                   //TODO: Update the failure cause in ue context Setup Response
12080                   ret = RFAILED;
12081                }
12082                break;
12083             }
12084
12085          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
12086             {
12087                drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
12088
12089                if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
12090                {
12091                   DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
12092                   //TODO: Update the failure cause in ue context Setup Response
12093                   ret = RFAILED;
12094                }
12095                break;
12096             }
12097
12098          case ProtocolIE_ID_id_RRCContainer:
12099             {
12100                /* Filling Dl RRC Msg Info */
12101                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
12102                if(!duUeCb->f1UeDb->dlRrcMsg)
12103                {
12104                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
12105                   ret = RFAILED;
12106                }
12107                else
12108                {
12109                   duUeCb->f1UeDb->dlRrcMsgPres = true;
12110                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
12111                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
12112                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
12113                }
12114                break;
12115             }
12116
12117          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12118             {
12119                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
12120                {
12121                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
12122                }
12123                else
12124                {
12125                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
12126                }
12127                break;
12128             }
12129
12130          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
12131             {
12132                /* MaximumBitRate Uplink */
12133                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
12134                if(bitRateSize > 0)
12135                {
12136                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
12137                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
12138                   {
12139                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
12140                      ret = RFAILED;
12141                   }
12142                   else
12143                   {
12144                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
12145                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
12146                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
12147                   }
12148                }
12149                else
12150                   ret = RFAILED;
12151                break;
12152             }
12153
12154          default:
12155             {
12156                break;
12157             }
12158       } /* End of switch */
12159
12160       /* In case of any failure in any IE */
12161       if(ret == RFAILED)
12162       {
12163          // BuildAndSendUeContextSetupRsp(cellId,ueId);
12164          DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
12165          break;
12166       }
12167    } /* End of for loop of IEs */
12168
12169    if(ret == ROK)
12170       ret = duProcUeContextSetupRequest(duUeCb);
12171
12172    freeAperDecodeF1UeContextSetupReq(ueSetReq);
12173    return ret;
12174
12175 }
12176 /*******************************************************************
12177  * @brief Free the memory allocated for Dl Tunnel Info
12178  *
12179  * @details
12180  *
12181  *    Function : freeDlTnlInfo
12182  *
12183  *    Functionality:
12184  *       Free the memory allocated for Dl Tunnel Info
12185  *
12186  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
12187  * @return void
12188  *
12189  * ****************************************************************/
12190
12191 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
12192 {
12193    uint8_t arrIdx = 0;
12194
12195    if(tnlInfo)
12196    {
12197       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
12198       {
12199          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
12200                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
12201          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
12202                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
12203          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
12204          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
12205       }
12206       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
12207    }
12208 }
12209
12210 /*******************************************************************
12211  * @brief Free the memory allocated for DRB setup List
12212  *
12213  * @details
12214  *
12215  *    Function : freeDrbSetupList
12216  *
12217  *    Functionality:
12218  *       Free the memory allocated for DRB setup list
12219  *
12220  * @params[in] DRBs_Setup_List_t *
12221  * @return void
12222  *
12223  * ****************************************************************/
12224 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
12225 {
12226    uint8_t arrIdx = 0;
12227    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
12228
12229    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12230    {
12231       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12232       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
12233       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
12234    }
12235    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12236 }
12237
12238 /*******************************************************************
12239  * @brief Free the memory allocated for UE Setup response
12240  *
12241  * @details
12242  *
12243  *    Function : FreeUeContextSetupRsp
12244  *
12245  *    Functionality:
12246  *       Free the memory allocated for UE Setup response
12247  *
12248  * @params[in] F1AP PDU for UE setup response
12249  * @return ROK     - success
12250  *         RFAILED - failure
12251  *
12252  * ****************************************************************/
12253 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
12254 {
12255    uint8_t idx;
12256    UEContextSetupResponse_t *ueSetRsp = NULLP;
12257
12258    if(f1apMsg)
12259    {
12260       if(f1apMsg->choice.successfulOutcome)
12261       {
12262          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
12263                     UEContextSetupResponse;
12264          if(ueSetRsp->protocolIEs.list.array)
12265          {
12266             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
12267             {
12268                if(ueSetRsp->protocolIEs.list.array[idx])
12269                {
12270                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
12271                   {
12272                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12273                         break;
12274                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12275                         break;
12276                      case ProtocolIE_ID_id_DUtoCURRCInformation:
12277                         {
12278                            CellGroupConfig_t *cellGrpCfg = NULLP;
12279                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
12280                                          DUtoCURRCInformation.cellGroupConfig;
12281                            if(cellGrpCfg->buf != NULLP)
12282                            {
12283                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
12284                               cellGrpCfg = NULLP;
12285                            }
12286                            break;
12287                         }
12288                     case ProtocolIE_ID_id_DRBs_Setup_List:
12289                         {
12290                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
12291                            break;
12292                         }
12293                      default:
12294                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
12295                         ueSetRsp->protocolIEs.list.array[idx]->id);
12296                         break;
12297                   }
12298                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
12299                         sizeof(UEContextSetupResponseIEs_t));
12300                }
12301             }
12302             DU_FREE(ueSetRsp->protocolIEs.list.array, \
12303                   ueSetRsp->protocolIEs.list.size);
12304          }
12305          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12306       }
12307       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12308    }
12309 }
12310
12311 /*******************************************************************
12312  *
12313  * @brief Builds Ue context Setup Rsp DU To CU Info
12314  *
12315  * @details
12316  *
12317  *    Function : EncodeUeCntxtDuToCuInfo
12318  *
12319  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
12320  *
12321  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
12322  *
12323  * @return ROK     - success
12324  *         RFAILED - failure
12325  *
12326  ******************************************************************/
12327
12328 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
12329 {
12330    asn_enc_rval_t        encRetVal;
12331
12332    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
12333    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
12334    encBufSize = 0;
12335    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
12336    /* Encode results */
12337    if(encRetVal.encoded == ENCODE_FAIL)
12338    {
12339       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
12340             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12341       return RFAILED;
12342    }
12343    else
12344    {
12345       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
12346       for(int i=0; i< encBufSize; i++)
12347       {
12348          printf("%x",encBuf[i]);
12349       }
12350    }
12351    duToCuCellGrp->size = encBufSize;
12352    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
12353    if(!duToCuCellGrp->buf)
12354    {
12355       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
12356    }
12357    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
12358    return ROK;
12359 }
12360
12361 /*******************************************************************
12362  *
12363  * @brief Fills Dl Gtp tunnel Info
12364  *
12365  * @details
12366  *
12367  *    Function : fillGtpTunnelforDl
12368  *
12369  *    Functionality: Fills Dl Gtp tunnel Info
12370  *
12371  * @params[in]
12372  *
12373  * @return ROK     - success
12374  *         RFAILED - failure
12375  *
12376  * ****************************************************************/
12377
12378 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
12379 {
12380    uint8_t bufSize = 0;
12381
12382    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
12383    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
12384    if(gtpDl->transportLayerAddress.buf == NULLP)
12385    {
12386       return RFAILED;
12387    }
12388    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
12389
12390    /*GTP TEID*/
12391    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
12392    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
12393    if(gtpDl->gTP_TEID.buf == NULLP)
12394    {
12395       return RFAILED;
12396    }
12397    bufSize = 3; /*forming an Octect String*/
12398    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
12399
12400    return ROK;
12401 }
12402
12403 /*******************************************************************
12404  *
12405  * @brief Fills DL Tunnel Setup List
12406  *
12407  * @details
12408  *
12409  *    Function : fillDlTnlSetupList
12410  *
12411  *    Functionality: Fills the DL Tunnel Setup List
12412  *
12413  * @params[in]
12414  *
12415  * @return ROK     - success
12416  *         RFAILED - failure
12417  *
12418  * ****************************************************************/
12419
12420 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
12421 {
12422    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
12423
12424    eleCount = 1;
12425    dlTnlInfo->list.count = eleCount;
12426    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
12427
12428    /* Initialize the DL Tnl Setup List Members */
12429    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
12430    if(dlTnlInfo->list.array == NULLP)
12431    {
12432       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
12433       ret = RFAILED;
12434    }
12435    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
12436    {
12437       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
12438       if(dlTnlInfo->list.array[arrIdx] == NULLP)
12439       {
12440          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
12441          return RFAILED;
12442       }
12443       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
12444       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
12445       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
12446       {
12447          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
12448          return RFAILED;
12449       }
12450       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
12451                tnlCfg->tnlCfg1);
12452       if(ret != ROK)
12453          break;
12454    }
12455    return ret;
12456 }
12457
12458 /*******************************************************************
12459  *
12460  * @brief Fills the Drb Setup List for Ue Context Setup Response
12461  *
12462  * @details
12463  *
12464  *    Function : fillDrbSetupList
12465  *
12466  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
12467  *
12468  * @params[in]
12469  *
12470  * @return ROK     - success
12471  *         RFAILED - failure
12472  *
12473  * ****************************************************************/
12474 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
12475 {
12476    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
12477    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
12478
12479    eleCount = ueCfg->numDrb;
12480    drbSetupList->list.count = eleCount;
12481    drbSetupList->list.size = \
12482         (eleCount * sizeof(DRBs_Setup_Item_t *));
12483
12484    /* Initialize the Drb Setup List Members */
12485    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
12486    if(drbSetupList->list.array == NULLP)
12487    {
12488       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
12489       ret = RFAILED;
12490    }
12491
12492    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
12493    {
12494       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
12495       if(drbSetupList->list.array[arrIdx] == NULLP)
12496       {
12497          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
12498          return RFAILED;
12499       }
12500       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12501       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
12502       drbItemIe->criticality = Criticality_reject;
12503       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
12504       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12505       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
12506           &ueCfg->upTnlInfo[arrIdx]);
12507       if(ret != ROK)
12508          break;
12509    }
12510    return ret;
12511 }
12512
12513 /*******************************************************************
12514  *
12515  * @brief Builds and sends the UE Setup Response
12516  *
12517  * @details
12518  *
12519  *    Function : BuildAndSendUeContextSetupRsp
12520  *
12521  *    Functionality: Constructs the UE Setup Response and sends
12522  *                   it to the DU through SCTP.
12523  *
12524  * @params[in] uint8_t cellId,uint8_t ueId
12525  *
12526  * @return ROK     - success
12527  *         RFAILED - failure
12528  *
12529  * ****************************************************************/
12530 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
12531 {
12532    uint8_t   idx, ret, cellIdx, elementCnt;
12533    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12534    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12535    asn_enc_rval_t  encRetVal;        /* Encoder return value */
12536    F1AP_PDU_t               *f1apMsg = NULLP;
12537    UEContextSetupResponse_t *ueSetRsp = NULLP;
12538    DuUeCb                   *ueCb = NULLP;
12539
12540    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
12541
12542    while(true)
12543    {
12544       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12545       if(f1apMsg == NULLP)
12546       {
12547          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12548          ret = RFAILED;
12549          break;
12550       }
12551
12552       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
12553       DU_ALLOC(f1apMsg->choice.successfulOutcome,
12554             sizeof(SuccessfulOutcome_t));
12555       if(f1apMsg->choice.successfulOutcome == NULLP)
12556       {
12557          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
12558          ret = RFAILED;
12559          break;
12560       }
12561
12562       f1apMsg->choice.successfulOutcome->procedureCode = \
12563                                                          ProcedureCode_id_UEContextSetup;
12564       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12565       f1apMsg->choice.successfulOutcome->value.present = \
12566                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
12567
12568       ueSetRsp =
12569          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
12570       elementCnt = 5;
12571       ueSetRsp->protocolIEs.list.count = elementCnt;
12572       ueSetRsp->protocolIEs.list.size = \
12573                                         elementCnt * sizeof(UEContextSetupResponse_t *);
12574
12575       /* Initialize the UESetup members */
12576       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
12577             ueSetRsp->protocolIEs.list.size);
12578       if(ueSetRsp->protocolIEs.list.array == NULLP)
12579       {
12580          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
12581          ret = RFAILED;
12582          break;
12583       }
12584
12585       for(idx=0; idx<elementCnt; idx++)
12586       {
12587          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
12588                sizeof(UEContextSetupResponseIEs_t));
12589          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
12590          {
12591             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
12592             ret = RFAILED;
12593             break;
12594          }
12595       }
12596       /* Fetching Ue Cb Info*/
12597       GET_CELL_IDX(cellId, cellIdx);
12598       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
12599       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
12600       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
12601
12602       idx = 0;
12603       /*GNB CU UE F1AP ID*/
12604       ueSetRsp->protocolIEs.list.array[idx]->id = \
12605                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12606       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12607       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
12608                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12609       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12610
12611       /*GNB DU UE F1AP ID*/
12612       idx++;
12613       ueSetRsp->protocolIEs.list.array[idx]->id = \
12614                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12615       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12616       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
12617                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12618       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12619
12620
12621       /*DUtoCURRC Information */
12622       idx++;
12623       ueSetRsp->protocolIEs.list.array[idx]->id  = \
12624                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
12625       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12626       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
12627                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
12628       BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
12629
12630       /* CRNTI */
12631       idx++;
12632       ueSetRsp->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_C_RNTI;
12633       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12634       ueSetRsp->protocolIEs.list.array[idx]->value.present = UEContextSetupResponseIEs__value_PR_C_RNTI;
12635       ueSetRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI = ueCb->crnti;
12636
12637
12638       /* Drb Setup List */
12639       idx++;
12640       ueSetRsp->protocolIEs.list.array[idx]->id  = \
12641                                                    ProtocolIE_ID_id_DRBs_Setup_List;
12642       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12643       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
12644                                                             UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
12645       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
12646             &ueCb->f1UeDb->duUeCfg);
12647       if(ret == RFAILED)
12648       {
12649          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
12650          freeF1UeDb(ueCb->f1UeDb);
12651          ueCb->f1UeDb = NULLP;
12652          break;
12653       }
12654
12655       /* Free UeContext Db created during Ue context Req */
12656       freeF1UeDb(ueCb->f1UeDb);
12657       ueCb->f1UeDb = NULLP;
12658
12659       /* TODO: To send Drb list */
12660       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12661
12662       /* Encode the UE context setup response type as APER */
12663       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
12664       encBufSize = 0;
12665       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12666             encBuf);
12667       /* Encode results */
12668       if(encRetVal.encoded == ENCODE_FAIL)
12669       {
12670          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
12671                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12672          ret = RFAILED;
12673          break;
12674       }
12675       else
12676       {
12677          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
12678          for(int i=0; i< encBufSize; i++)
12679          {
12680             printf("%x",encBuf[i]);
12681          }
12682       }
12683
12684       /* Sending  msg  */
12685       if(sendF1APMsg()  != ROK)
12686       {
12687          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
12688          ret = RFAILED;
12689          break;
12690       }
12691       break;
12692    }
12693    FreeUeContextSetupRsp(f1apMsg);
12694    return ret;
12695 }/* End of BuildAndSendUeContextSetupRsp */
12696 /*******************************************************************
12697 *
12698 * @brief  Build And Send Ue Context Rsp
12699 *
12700 * @details
12701 *
12702 *    Function : BuildAndSendUeCtxtRsp
12703 *
12704 *    Functionality : Build And Send Ue Context Rsp
12705
12706 * @params[in]
12707 * @return sucess = ROK
12708 *         failure = RFAILED
12709 *
12710 * ****************************************************************/
12711 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
12712 {
12713    uint8_t cellIdx = 0, actionType = 0;
12714
12715    GET_CELL_IDX(cellId, cellIdx);
12716    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
12717
12718    switch(actionType)
12719    {
12720       case UE_CTXT_SETUP:
12721          {
12722             if((BuildAndSendUeContextSetupRsp(cellId,ueId)) != ROK)
12723             {
12724                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextSetupRsp()");
12725                return RFAILED;
12726             }
12727             break;
12728          }
12729       case UE_CTXT_MOD:
12730          {
12731             if((BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1])) != ROK)
12732             {
12733                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextModRsp");
12734                return RFAILED;
12735             }
12736             break;
12737          }
12738       default:
12739          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
12740          break;
12741
12742    }
12743    return ROK;
12744 }
12745
12746 /*******************************************************************
12747  *
12748  * @brief deallocating the memory of  F1reset msg
12749  *
12750  * @details
12751  *
12752  *    Function : FreeF1ResetReq
12753  *
12754  *    Functionality :
12755  *         - freeing memory of F1reset request msg
12756  *
12757  * @params[in]
12758  * @return void
12759  *
12760  *
12761  * ****************************************************************/
12762 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
12763 {
12764    uint8_t idx =0 ;
12765    Reset_t *f1ResetMsg;
12766
12767    if(f1apMsg)
12768    {
12769       if(f1apMsg->choice.initiatingMessage)
12770       {
12771          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
12772
12773          if(f1ResetMsg->protocolIEs.list.array)
12774          {
12775             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
12776             {
12777                if(f1ResetMsg->protocolIEs.list.array[idx])
12778                {
12779                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
12780                }
12781             }
12782             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
12783          }
12784          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12785       }
12786       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12787    }
12788 }
12789 /*******************************************************************
12790  *
12791  * @brief Build and Send F1reset request
12792  *
12793  * @details
12794  *
12795  *    Function : BuildAndSendF1ResetReq
12796  *
12797  *    Functionality:
12798  *         - Build and Send F1reset request msg
12799  *
12800  * @params[in]
12801  * @return ROK     - success
12802  *         RFAILED - failure
12803  *
12804  * ****************************************************************/
12805 uint8_t BuildAndSendF1ResetReq()
12806 {
12807    uint8_t          elementCnt=0;
12808    uint8_t          idx=0;
12809    uint8_t          ret= RFAILED;
12810    Reset_t          *f1ResetMsg = NULLP;
12811    F1AP_PDU_t       *f1apMsg = NULLP;
12812    asn_enc_rval_t   encRetVal;
12813    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
12814    do
12815    {
12816       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12817       if(f1apMsg == NULLP)
12818       {
12819          break;
12820       }
12821       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12822       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12823       if(f1apMsg->choice.initiatingMessage == NULLP)
12824       {
12825          break;
12826       }
12827       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
12828       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12829       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
12830
12831       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
12832
12833       elementCnt = 3;
12834       f1ResetMsg->protocolIEs.list.count = elementCnt;
12835       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
12836
12837       /* Initialize the F1Setup members */
12838       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
12839       if(f1ResetMsg->protocolIEs.list.array == NULLP)
12840       {
12841          break;
12842       }
12843       for(idx=0; idx<elementCnt; idx++)
12844       {
12845          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
12846          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
12847          {
12848             break;
12849          }
12850       }
12851
12852       /*TransactionID*/
12853       idx=0;
12854       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
12855       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12856       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
12857       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
12858
12859       /*Cause*/
12860       idx++;
12861       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
12862       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
12863       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
12864       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
12865       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
12866
12867       /*Reset Type*/
12868       idx++;
12869       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
12870       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12871       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
12872       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
12873       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
12874
12875       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12876
12877       /* Encode the F1SetupRequest type as APER */
12878       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12879       encBufSize = 0;
12880       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12881             encBuf);
12882
12883       /* Encode results */
12884       if(encRetVal.encoded == ENCODE_FAIL)
12885       {
12886          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
12887                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12888          break;
12889       }
12890       else
12891       {
12892          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
12893          for(idx=0; idx< encBufSize; idx++)
12894          {
12895             printf("%x",encBuf[idx]);
12896          }
12897       }
12898
12899       if(sendF1APMsg() != ROK)
12900       {
12901          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
12902          break;
12903       }
12904
12905       ret = ROK;
12906       break;
12907    }while(true);
12908
12909    FreeF1ResetReq(f1apMsg);
12910    return ret;
12911 }
12912 /*******************************************************************
12913  *
12914  * @brief Build And Send F1ResetAck
12915  *
12916  * @details
12917  *
12918  *    Function : BuildAndSendF1ResetAck
12919  *
12920  *    Functionality:
12921  *         - Build And Send  F1ResetRSP
12922  *
12923  * @return ROK     - success
12924  *         RFAILED - failure
12925  *
12926  * ****************************************************************/
12927 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
12928 {
12929    uint8_t idx;
12930    ResetAcknowledge_t *f1ResetAck;
12931
12932    if(f1apMsg)
12933    {
12934       if(f1apMsg->choice.successfulOutcome)
12935       {
12936          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
12937
12938          if(f1ResetAck->protocolIEs.list.array)
12939          {
12940             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
12941             {
12942                if(f1ResetAck->protocolIEs.list.array[idx])
12943                {
12944                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
12945                }
12946             }
12947             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
12948          }
12949          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12950       }
12951       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12952    }
12953 }
12954
12955 /*******************************************************************
12956  *
12957  * @brief Build And Send F1ResetAck
12958  *
12959  * @details
12960  *
12961  *    Function : BuildAndSendF1ResetAck
12962  *
12963  *    Functionality:
12964  *         - Build And Send  F1ResetRSP
12965  *
12966  *  @params[in]
12967  * @return ROK     - success
12968  *         RFAILED - failure
12969  *
12970  * ****************************************************************/
12971 uint8_t BuildAndSendF1ResetAck()
12972 {
12973    uint8_t                idx = 0;
12974    uint8_t                elementCnt = 0;
12975    uint8_t                ret = RFAILED;
12976    F1AP_PDU_t             *f1apMsg = NULL;
12977    ResetAcknowledge_t     *f1ResetAck = NULLP;
12978    asn_enc_rval_t         encRetVal;
12979    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
12980
12981    do{
12982       /* Allocate the memory for F1ResetRequest_t */
12983       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12984       if(f1apMsg == NULLP)
12985       {
12986          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12987          break;
12988       }
12989
12990       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12991
12992       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12993       if(f1apMsg->choice.successfulOutcome == NULLP)
12994       {
12995          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12996          break;
12997       }
12998       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
12999       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
13000       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
13001
13002       elementCnt = 1;
13003
13004       f1ResetAck->protocolIEs.list.count = elementCnt;
13005       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
13006
13007       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
13008       if(f1ResetAck->protocolIEs.list.array == NULLP)
13009       {
13010          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
13011          break;
13012       }
13013
13014       for(idx=0; idx<elementCnt; idx++)
13015       {
13016          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
13017          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
13018          {
13019             break;
13020          }
13021       }
13022       /*TransactionID*/
13023       idx = 0;
13024       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
13025       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
13026       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
13027       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
13028
13029       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13030
13031       /* Encode the F1SetupRequest type as UPER */
13032       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13033       encBufSize = 0;
13034       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13035
13036       /* Check encode results */
13037       if(encRetVal.encoded == ENCODE_FAIL)
13038       {
13039          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
13040                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13041          break;
13042       }
13043       else
13044       {
13045          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
13046          for(int i=0; i< encBufSize; i++)
13047          {
13048             printf("%x",encBuf[i]);
13049          }
13050       }
13051       /* Sending msg */
13052       if(sendF1APMsg() != ROK)
13053       {
13054          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
13055          break;
13056       }
13057
13058       ret = ROK;
13059       break;
13060    }while(true);
13061
13062    FreeF1ResetAck(f1apMsg);
13063    return ret;
13064 }
13065 /******************************************************************
13066 *
13067 * @brief free F1 reset msg allocated by aper_decoder
13068 *
13069 * @details
13070 *
13071 *    Function : freeAperDecodeF1ResetMsg
13072 *
13073 *    Functionality: free F1 reset msg allocated by aper_decoder
13074 *
13075 * @params[in] Reset_t *f1ResetMsg
13076 * @return void
13077 *
13078 * ****************************************************************/
13079
13080 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
13081 {
13082    uint8_t ieIdx =0;
13083    if(f1ResetMsg->protocolIEs.list.array)
13084    {
13085       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
13086       {
13087          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
13088          {
13089             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
13090          }
13091       }
13092       free(f1ResetMsg->protocolIEs.list.array);
13093    }
13094 }
13095
13096 /******************************************************************
13097  *
13098  * @brief Processes DL RRC Message Transfer  sent by CU
13099  *
13100  * @details
13101  *
13102  *    Function : procF1ResetReq
13103  *
13104  *    Functionality: Processes DL RRC Message Transfer sent by CU
13105  *
13106  * @params[in] F1AP_PDU_t ASN decoded F1AP message
13107  * @return ROK     - success
13108  *         RFAILED - failure
13109  *
13110  * ****************************************************************/
13111 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
13112 {
13113    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
13114    uint8_t       ieIdx = 0;
13115    uint8_t        ret = ROK;
13116    Reset_t       *f1ResetMsg = NULLP;
13117
13118    DU_LOG("\nINFO   -->  Processing F1 reset request");
13119    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
13120
13121    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
13122    {
13123       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
13124       {
13125          case ProtocolIE_ID_id_TransactionID:
13126             break;
13127
13128          case ProtocolIE_ID_id_Cause:
13129             break;
13130
13131          case ProtocolIE_ID_id_ResetType:
13132             {
13133                break;
13134             }
13135
13136          default:
13137             break;
13138       }
13139    }
13140    ret = BuildAndSendF1ResetAck();
13141    DU_LOG("\nINFO   -->  UE release is not supported for now");
13142
13143    freeAperDecodeF1ResetMsg(f1ResetMsg);
13144
13145    return ret;
13146 }
13147
13148 /*******************************************************************
13149  *
13150  * @brief free the RRC delivery report
13151  *
13152  * @details
13153  *
13154  *    Function : freeRrcDeliveryReport
13155  *
13156  *    Functionality: free the RRC delivery report
13157  *
13158  * @params[in]
13159  * @return ROK     - success
13160  *         RFAILED - failure
13161  *
13162  * ****************************************************************/
13163 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
13164 {
13165    uint8_t idx=0;
13166    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
13167
13168    if(f1apMsg)
13169    {
13170       if(f1apMsg->choice.initiatingMessage)
13171       {
13172          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
13173          if(rrcDeliveryReport->protocolIEs.list.array)
13174          {
13175             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
13176                   idx++)
13177             {
13178                if(rrcDeliveryReport->protocolIEs.list.array[idx])
13179                {
13180                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
13181                         sizeof(RRCDeliveryReportIEs_t));
13182                }
13183             }
13184             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
13185                   rrcDeliveryReport->protocolIEs.list.size);
13186          }
13187          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
13188       }
13189       DU_FREE(f1apMsg,
13190             sizeof(F1AP_PDU_t));
13191    }
13192 }
13193
13194 /*******************************************************************
13195 *
13196 * @brief Builds and sends the RRC delivery report
13197 *
13198 * @details
13199 *
13200 *    Function : BuildAndSendRrcDeliveryReport
13201 *
13202 *    Functionality: Builds and sends the RRC delivery report
13203 *
13204 * @params[in]
13205 *
13206 * @return ROK     - success
13207 *         RFAILED - failure
13208 *
13209 * ****************************************************************/
13210 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
13211    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
13212 {
13213    uint8_t             ret = RFAILED;
13214    uint8_t             idx    = 0;
13215    uint8_t             idx1   = 0;
13216    uint8_t             elementCnt = 0;
13217    F1AP_PDU_t          *f1apMsg = NULLP;
13218    asn_enc_rval_t      encRetVal;
13219    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
13220
13221    do{
13222
13223       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
13224       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13225       if(f1apMsg == NULLP)
13226       {
13227          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
13228          break;
13229       }
13230       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13231       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
13232       if(f1apMsg->choice.initiatingMessage == NULLP)
13233       {
13234          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
13235          break;
13236       }
13237       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
13238       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
13239       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
13240
13241       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
13242       elementCnt = 4;
13243       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
13244       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
13245
13246       /* Initialize the F1Setup members */
13247       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
13248       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
13249       {
13250          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
13251          break;
13252       }
13253       for(idx =0 ;idx <elementCnt; idx++)
13254       {
13255          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
13256          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
13257          {
13258             break;
13259          }
13260       }
13261
13262       idx1 = 0;
13263
13264       /*GNB CU UE F1AP ID*/
13265       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13266       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
13267       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
13268       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
13269
13270       /*GNB DU UE F1AP ID*/
13271       idx1++;
13272       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13273       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
13274       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
13275       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
13276
13277       /*RRC delivery status*/
13278       idx1++;
13279       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
13280       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
13281       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
13282       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
13283       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
13284       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
13285       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
13286
13287       /* SRB ID */
13288       idx1++;
13289       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
13290       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
13291       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
13292       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
13293
13294       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13295
13296       /* Encode the RRC DELIVERY REPORT type as APER */
13297       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13298       encBufSize = 0;
13299       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
13300             encBuf);
13301
13302       /* Encode results */
13303       if(encRetVal.encoded == ENCODE_FAIL)
13304       {
13305          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
13306                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13307          break;
13308       }
13309       else
13310       {
13311          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
13312          for(idx=0; idx< encBufSize; idx++)
13313          {
13314             printf("%x",encBuf[idx]);
13315          }
13316       }
13317
13318       /* Sending msg */
13319       if(sendF1APMsg() != ROK)
13320       {
13321          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
13322          break;
13323       }
13324       ret = ROK;
13325       break;
13326
13327    }while(true);
13328
13329    freeRrcDeliveryReport(f1apMsg);
13330    return ret;
13331 }
13332
13333 /*******************************************************************
13334  *
13335  * @brief Processes cells to be activated
13336  *
13337  * @details
13338  *
13339  *    Function : extractCellsToBeActivated
13340  *
13341  *    Functionality:
13342  *      - Processes cells to be activated list received in F1SetupRsp
13343  *
13344  * @params[in] void
13345  * @return ROK     - success
13346  *         RFAILED - failure
13347  *
13348  * ****************************************************************/
13349
13350 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
13351 {
13352    uint8_t  ret = ROK;
13353    uint16_t idx, nci, pci = 0;
13354    Cells_to_be_Activated_List_Item_t cell;
13355
13356    for(idx=0; idx<cellsToActivate.list.count; idx++)
13357    {
13358       nci = 0;
13359       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
13360       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
13361
13362       if(cell.nRPCI)
13363       {
13364          pci = *cell.nRPCI;
13365       }
13366       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
13367    }
13368    return ret;
13369 }
13370 /******************************************************************
13371 *
13372 * @brief Processes F1 Setup Response allocated by aper_decoder
13373 *
13374 * @details
13375 *
13376 *    Function : freeF1SetupRsp
13377 *
13378 *    Functionality: free F1 Setup Response allocated by aper_decoder
13379 *
13380 * @params[in] F1SetupResponse_t *f1SetRspMsg
13381 * @return void
13382 *
13383 * ****************************************************************/
13384
13385 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
13386 {
13387    uint8_t ieIdx =0;
13388    uint8_t arrIdx =0;
13389    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
13390    RRC_Version_t      *rrcVer =NULLP;
13391
13392    if(f1SetRspMsg->protocolIEs.list.array)
13393    {
13394       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
13395       {
13396          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
13397          {
13398             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
13399             {
13400                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
13401                   {
13402                      cellToActivate =
13403                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
13404                      if(cellToActivate->list.array)
13405                      {
13406                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
13407                         {
13408                            if(cellToActivate->list.array[arrIdx])
13409                            {
13410
13411                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
13412                               pLMN_Identity.buf)
13413                               {
13414                                  if(cellToActivate->list.array[0]->value.choice.\
13415                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
13416                                  {
13417                                     free(cellToActivate->list.array[0]->value.choice.\
13418                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
13419                                  }
13420
13421                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
13422                                        nRCGI.pLMN_Identity.buf);
13423                               }
13424                               free(cellToActivate->list.array[arrIdx]);
13425                            }
13426                         }
13427                         free(cellToActivate->list.array);
13428                      }
13429                      break;
13430                   }
13431                case ProtocolIE_ID_id_TransactionID:
13432                   {
13433                      break;
13434                   }
13435                case ProtocolIE_ID_id_gNB_CU_Name:
13436                   {
13437                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
13438                      break;
13439                   }
13440                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
13441                   {
13442                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
13443                      if(rrcVer->latest_RRC_Version.buf)
13444                      {
13445                         if(rrcVer->iE_Extensions)
13446                         {
13447                            if(rrcVer->iE_Extensions->list.array)
13448                            {
13449                               if(rrcVer->iE_Extensions->list.array[0])
13450                               {
13451                                  if(rrcVer->iE_Extensions->list.\
13452                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
13453                                  {
13454                                     free(rrcVer->iE_Extensions->list.\
13455                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
13456                                  }
13457                                  free(rrcVer->iE_Extensions->list.array[0]);
13458                               }
13459                               free(rrcVer->iE_Extensions->list.array);
13460                            }
13461                            free(rrcVer->iE_Extensions);
13462                         }
13463                         free(rrcVer->latest_RRC_Version.buf);
13464                      }
13465                      break;
13466
13467                   }
13468                default:
13469                   {
13470                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
13471                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
13472                   }
13473             }
13474             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
13475          }
13476       }
13477       free(f1SetRspMsg->protocolIEs.list.array);
13478    }
13479 }
13480 /******************************************************************
13481  *
13482  * @brief Processes F1 Setup Response sent by CU
13483  *
13484  * @details
13485  *
13486  *    Function : procF1SetupRsp
13487  *
13488  *    Functionality: Processes F1 Setup Response sent by CU
13489  *
13490  * @params[in] F1AP_PDU_t ASN decoded F1AP message
13491  * @return ROK     - success
13492  *         RFAILED - failure
13493  *
13494  * ****************************************************************/
13495 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
13496 {
13497    uint8_t ret = ROK;
13498    uint16_t idx =0;
13499    F1SetupResponse_t *f1SetRspMsg = NULLP;
13500    GNB_CU_Name_t     *cuName = NULLP;
13501    F1SetupRsp  f1SetRspDb;
13502    RRC_Version_t      *rrcVer =NULLP;
13503
13504    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
13505
13506    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
13507    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
13508
13509    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
13510    {
13511       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
13512       {
13513          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
13514             {
13515                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
13516                      value.choice.Cells_to_be_Activated_List);
13517                break;
13518             }
13519          case ProtocolIE_ID_id_TransactionID:
13520             {
13521                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
13522                                     value.choice.TransactionID;
13523                break;
13524             }
13525          case ProtocolIE_ID_id_gNB_CU_Name:
13526             {
13527                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
13528                         value.choice.GNB_CU_Name;
13529                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
13530                break;
13531             }
13532          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
13533             {
13534                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
13535                strcpy(f1SetRspDb.rrcVersion.rrcVer,
13536                      (const char*)rrcVer->latest_RRC_Version.buf);
13537                break;
13538             }
13539          default:
13540             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
13541                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
13542       }
13543       duProcF1SetupRsp();
13544    }
13545
13546    freeAperDecodeF1SetupRsp(f1SetRspMsg);
13547
13548    duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
13549    DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
13550    if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
13551    {
13552       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the buf of F1setup response");
13553       return RFAILED;
13554    }
13555    memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
13556
13557    if(BuildAndSendE2SetupReq() != ROK)
13558    {
13559       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
13560       return RFAILED;
13561    }
13562    return ret;
13563 }
13564 /*******************************************************************
13565 *
13566 * @brief free GNB DU config update ack
13567 *
13568 * @details
13569 *
13570 *    Function : freeAperDecodeGnbDuAck
13571 *
13572 *    Functionality: Processes GNB DU config update ack And
13573 *                     added free part for the memory allocated by aper_decoder
13574 *
13575 * @params[in] F1AP_PDU_t ASN decoded F1AP message
13576 * @return ROK     - success
13577 *         RFAILED - failure
13578 *
13579 * ****************************************************************/
13580
13581 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
13582 {
13583    uint8_t ieIdx = 0;
13584
13585    if(gnbDuAck->protocolIEs.list.array)
13586    {
13587       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
13588       {
13589          if(gnbDuAck->protocolIEs.list.array[ieIdx])
13590          {
13591             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
13592          }
13593       }
13594       free(gnbDuAck->protocolIEs.list.array);
13595    }
13596 }
13597
13598 /*******************************************************************
13599 *
13600 * @brief Building  result of gnb-du config update ack output
13601 *
13602 * @details
13603 *
13604 *    Function : duProcGnbDuCfgUpdAckMsg
13605 *
13606 *    Functionality:
13607 *        Building output of gnb-du config update ack
13608 *
13609 * @params[in] transId
13610 * @return void
13611 *
13612 * ****************************************************************/
13613
13614 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
13615 {
13616    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
13617    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
13618    uint16_t cellId =0, cellIdx =0, crnti=0;
13619    CmLList *f1apPduNode = NULLP;
13620    ReservedF1apPduInfo *f1apPduInfo =NULLP;
13621    F1AP_PDU_t *f1apMsgPdu = NULLP;
13622    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
13623    BIT_STRING_t *cellIdentity=NULLP;
13624    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
13625    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
13626    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
13627
13628    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
13629    f1apPduNode = searchFromReservedF1apPduList(transId);
13630    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
13631    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
13632
13633    if(f1apMsgPdu)
13634    {
13635       if(f1apMsgPdu->choice.initiatingMessage)
13636       {
13637          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
13638          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
13639          {
13640             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
13641             {
13642                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
13643                   {
13644                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
13645                                      Served_Cells_To_Delete_List;
13646                      if(cellsToDelete->list.array)
13647                      {
13648                         if(cellsToDelete->list.array[arrIdx])
13649                         {
13650                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
13651                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
13652                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
13653                            {
13654                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
13655                               bitStringToInt(cellIdentity, &cellId);
13656
13657                               GET_CELL_IDX(cellId, cellIdx);
13658                               if(duCb.actvCellLst[cellIdx] != NULLP)
13659                               {
13660                                  duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13661                               }
13662                            }
13663                         }
13664                      }
13665
13666                      if(duCb.actvCellLst[cellIdx] != NULLP)
13667                      {
13668                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
13669                         {
13670                            ret = duSendCellDeletReq(cellId);
13671                            if(ret == RFAILED)
13672                            {
13673                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
13674                               request for cellId[%d]", cellId);
13675                            }
13676                         }
13677                         else
13678                         {
13679                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
13680                            while(totalActiveUe)
13681                            {
13682                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
13683                               {
13684                                  ueIdx++;
13685                                  continue;
13686                               }
13687
13688                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
13689                               GET_UE_ID(crnti,ueId);
13690                               /* Sending Ue Context release request only for maximum supporting UEs */
13691                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
13692                               if(ret == RFAILED)
13693                               {
13694                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
13695                                  request for cellId[%d]", cellId);
13696                               }
13697                               ueIdx++;
13698                               totalActiveUe--;
13699                            }
13700                         }
13701                      }
13702                      else
13703                      {
13704                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
13705                         ret = RFAILED;
13706                      }
13707                      break;
13708                   }
13709
13710                default:
13711                   break;
13712             }
13713          }
13714       }
13715    }
13716
13717    FreeDUConfigUpdate(f1apMsgPdu);
13718    deleteFromReservedF1apPduList(f1apPduNode);
13719    return ret;
13720 }
13721
13722 /*******************************************************************
13723 *
13724 * @brief Processes GNB DU config update ack
13725 *
13726 * @details
13727 *
13728 *    Function : procF1GNBDUCfgUpdAck
13729 *
13730 *    Functionality: added free part for the memory allocated by aper_decoder
13731 *
13732 * @params[in] F1AP_PDU_t *f1apMsg
13733 * @return void
13734 *
13735 * ****************************************************************/
13736 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
13737 {
13738    uint8_t ieIdx=0,transId=0;
13739    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
13740
13741    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
13742    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
13743
13744    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
13745    {
13746       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
13747       {
13748          case ProtocolIE_ID_id_TransactionID:
13749             {
13750                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
13751                break;
13752             }
13753          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
13754             {
13755                break;
13756             }
13757          default :
13758             {
13759                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
13760                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
13761                break;
13762             }
13763       }
13764    }
13765
13766    duProcGnbDuCfgUpdAckMsg(transId);
13767
13768 #if 0
13769    /* presently we are not supporting F1 Reset from DU to CU , we are only
13770     * supporting F1 Reset from CU to DU */
13771
13772    if(BuildAndSendF1ResetReq() != ROK)
13773    {
13774       return RFAILED;
13775    }
13776 #endif
13777
13778    freeAperDecodeGnbDuAck(gnbDuAck);
13779    return ROK;
13780 }
13781 /******************************************************************
13782 *
13783 * @brief free DL RRC Message Transfer allocated by aper_decoder
13784 *
13785 * @details
13786 *
13787 *    Function : freeAperDecodef1DlRrcMsg
13788 *
13789 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
13790 *
13791 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
13792 * @return ROK     - success
13793 *         RFAILED - failure
13794 *
13795 * ****************************************************************/
13796
13797 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
13798 {
13799    uint8_t ieIdx =0;
13800    RRCContainer_t *rrcContainer = NULLP;
13801
13802    if(f1DlRrcMsg->protocolIEs.list.array)
13803    {
13804       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
13805       {
13806          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
13807          {
13808             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
13809             {
13810                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13811                   break;
13812                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13813                   break;
13814                case ProtocolIE_ID_id_SRBID:
13815                   break;
13816                case ProtocolIE_ID_id_RRCContainer:
13817                   {
13818                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
13819                      free(rrcContainer->buf);
13820                   }
13821                case ProtocolIE_ID_id_ExecuteDuplication:
13822                   break;
13823                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13824                   break;
13825                   break;
13826             }
13827             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
13828          }
13829       }
13830       free(f1DlRrcMsg->protocolIEs.list.array);
13831    }
13832 }
13833 /******************************************************************
13834  *
13835  * @brief Processes DL RRC Message Transfer  sent by CU
13836  *
13837  * @details
13838  *
13839  *    Function : procF1DlRrcMsgTrans
13840  *
13841  *    Functionality: Processes DL RRC Message Transfer sent by CU
13842  *
13843  * @params[in] F1AP_PDU_t ASN decoded F1AP message
13844  * @return ROK     - success
13845  *         RFAILED - failure
13846  *
13847  * ****************************************************************/
13848 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
13849 {
13850    uint8_t  idx, ret;
13851    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
13852    F1DlRrcMsg dlMsg;
13853    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
13854
13855    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
13856    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
13857
13858    ret = ROK;
13859
13860    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
13861    {
13862       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
13863       {
13864          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13865             {
13866                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
13867                break;
13868             }
13869          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13870             {
13871                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
13872                break;
13873             }
13874          case ProtocolIE_ID_id_SRBID:
13875             {
13876                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
13877                break;
13878             }
13879          case ProtocolIE_ID_id_ExecuteDuplication:
13880             dlMsg.execDup = true;
13881             break;
13882
13883          case ProtocolIE_ID_id_RRCContainer:
13884             {
13885                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
13886                {
13887                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
13888                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
13889                   if(dlMsg.rrcMsgPdu)
13890                   {
13891                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
13892                         dlMsg.rrcMsgSize);
13893                   }
13894                   else
13895                   {
13896                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
13897                      return RFAILED;
13898                   }
13899                }
13900                else
13901                {
13902                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
13903                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
13904                   return RFAILED;
13905                }
13906                break;
13907             }
13908          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13909             {
13910                dlMsg.deliveryStatRpt = true;
13911                break;
13912             }
13913          default:
13914             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
13915                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
13916       }
13917    }
13918
13919    ret = duProcDlRrcMsg(&dlMsg);
13920
13921    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
13922    return ret;
13923 }
13924 /*******************************************************************
13925  *
13926 * @brief Builds the DRB to be Setup Mod list
13927 *
13928 * @details
13929 *
13930 *    Function :
13931 *
13932 *    Functionality: Constructs the DRB to be Setup Mod list
13933 *
13934 * @params[in] DRBs_SetupMod_List_t *drbSet
13935 *
13936 * @return ROK     - success
13937 *         RFAILED - failure
13938 *
13939 * ****************************************************************/
13940 uint8_t BuildSrbSetupModList(SRBs_SetupMod_List_t *srbList, DuUeCfg *ueCfg)
13941 {
13942    uint8_t srbIdx = 0;
13943    struct SRBs_SetupMod_ItemIEs *srbItemIe;
13944
13945    srbList->list.count = ueCfg->numRlcLcs;
13946    srbList->list.size = srbList->list.count * sizeof(SRBs_SetupMod_ItemIEs_t *);
13947
13948    DU_ALLOC(srbList->list.array, srbList->list.size);
13949    if(srbList->list.array == NULLP)
13950    {
13951       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
13952       return RFAILED;
13953    }
13954
13955    for(srbIdx = 0; srbIdx < srbList->list.count; srbIdx++)
13956    {
13957       DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
13958       if(srbList->list.array[srbIdx] == NULLP)
13959       {
13960          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
13961          return RFAILED;
13962       }
13963    }
13964
13965    for(srbIdx=0; srbIdx < srbList->list.count; srbIdx++)
13966    {
13967       srbItemIe = (struct SRBs_SetupMod_ItemIEs *)srbList->list.array[srbIdx];
13968       srbItemIe->id = ProtocolIE_ID_id_SRBs_SetupMod_Item;
13969       srbItemIe->criticality = Criticality_reject;
13970       srbItemIe->value.present = SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item;
13971       srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID = ueCfg->rlcLcCfg[srbIdx].rbId;
13972       srbItemIe->value.choice.SRBs_SetupMod_Item.lCID = ueCfg->rlcLcCfg[srbIdx].lcId;
13973    }
13974    return ROK;
13975 }
13976
13977 /*******************************************************************
13978  *
13979 * @brief Builds the DRB to be Setup Mod list
13980 *
13981 * @details
13982 *
13983 *    Function :
13984 *
13985 *    Functionality: Constructs the DRB to be Setup Mod list
13986 *
13987 * @params[in] DRBs_SetupMod_List_t *drbSet
13988 *
13989 * @return ROK     - success
13990 *         RFAILED - failure
13991 *
13992 * ****************************************************************/
13993
13994 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
13995 {
13996    uint8_t arrIdx =0;
13997    uint8_t drbCnt =0;
13998    struct DRBs_SetupMod_ItemIEs *drbItemIe;
13999
14000    drbCnt = ueCfg->numDrbSetupMod;
14001
14002    if(!drbCnt)
14003    {
14004       DU_LOG("\nINFO  -->  F1AP : BuildDrbToBeSetupModList(): No DRB information to avaialble to add");
14005       return ROK;
14006    }
14007
14008    drbSet->list.count = drbCnt;
14009    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
14010    DU_ALLOC(drbSet->list.array, drbSet->list.size);
14011    if(drbSet->list.array == NULLP)
14012    {
14013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
14014       return  RFAILED;
14015    }
14016    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
14017    {
14018       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
14019       if(drbSet->list.array[arrIdx] == NULLP)
14020       {
14021               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
14022               return  RFAILED;
14023       }
14024
14025       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
14026       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
14027       drbItemIe->criticality = Criticality_reject;
14028       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
14029       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
14030       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
14031       &ueCfg->upTnlInfo[arrIdx])!= ROK)
14032       {
14033          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
14034          return RFAILED;
14035       }
14036
14037    }
14038
14039    return ROK;
14040 }
14041 /*******************************************************************
14042 * @brief Free the memory allocated for DRB setup List
14043 *
14044 * @details
14045 *
14046 *    Function : FreeDrbSetupModList
14047 *
14048 *    Functionality:
14049 *       Free the memory allocated for DRB setup list
14050 *
14051 * @params[in] DRBs_Setup_List_t *
14052 * @return void
14053 *
14054 * ****************************************************************/
14055 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
14056 {
14057    uint8_t arrIdx = 0;
14058    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
14059
14060    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
14061    {
14062       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
14063       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
14064       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
14065    }
14066    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
14067 }
14068
14069 /*******************************************************************
14070 * @brief Free the memory allocated for SRB setup List
14071 *
14072 * @details
14073 *
14074 *    Function : FreeSrbSetupModList
14075 *
14076 *    Functionality:
14077 *       Free the memory allocated for SRB setup list
14078 *
14079 * @params[in] SRBs_Setup_List_t *
14080 * @return void
14081 *
14082 * ****************************************************************/
14083 void FreeSrbSetupModList(SRBs_SetupMod_List_t *srbSetupList)
14084 {
14085    uint8_t srbIdx = 0;
14086
14087    for(srbIdx = 0; srbIdx < srbSetupList->list.count; srbIdx++)
14088       DU_FREE(srbSetupList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
14089    DU_FREE(srbSetupList->list.array, srbSetupList->list.size);
14090 }
14091
14092 /*******************************************************************
14093 * @brief Free the memory allocated for UE Context Mod Response
14094 *
14095 * @details
14096 *
14097 *    Function : FreeUeContextModResp
14098 *
14099 *    Functionality:
14100 *       Free the memory allocated for UE Context Mod Response
14101 *
14102 * @params[in] F1AP_PDU_t *f1apMsg
14103 * @return void
14104 *
14105 * ****************************************************************/
14106
14107 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
14108 {
14109    uint8_t ieIdx;
14110    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
14111    if(f1apMsg)
14112    {
14113       if(f1apMsg->choice.successfulOutcome)
14114       {
14115          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
14116          if(ueContextModifyRes->protocolIEs.list.array)
14117          {
14118             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
14119             {
14120                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
14121                {
14122                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
14123                   {
14124                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14125                         break;
14126                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14127                         break;
14128                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
14129                         {
14130                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
14131                             value.choice.DRBs_SetupMod_List));
14132                             break;
14133                         }
14134                      case ProtocolIE_ID_id_SRBs_SetupMod_List:
14135                         {
14136                            FreeSrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
14137                               SRBs_SetupMod_List));
14138                            break;
14139                         }
14140                   }
14141                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
14142                }
14143
14144             }
14145             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
14146          }
14147          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14148       }
14149       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14150    }
14151 }
14152
14153 /*****************************************************************i
14154 *
14155 * @brief Creating the ue context modifcation response and sending
14156 *
14157 * @details
14158 *
14159 *    Function : BuildAndSendUeContextModRsp
14160 *
14161 *    Functionality:
14162 *         - Creating the ue context modifcation response
14163 *
14164 * @params[in] uint8_t cellId,uint8_t ueId
14165 * @return ROK     - success
14166 *         RFAILED - failure
14167 *
14168 * ****************************************************************/
14169 uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb)
14170 {
14171    uint8_t   ieIdx = 0, tnlIdx = 0, rbIdx = 0;
14172    uint8_t   elementCnt = 0;
14173    uint8_t   ret = RFAILED;
14174    F1AP_PDU_t *f1apMsg = NULLP;
14175    asn_enc_rval_t  encRetVal;
14176    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
14177
14178    DU_LOG("\nINFO  -->  F1AP : Building UE context modification response\n");
14179
14180    while(1)
14181    {
14182       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14183       if(f1apMsg == NULLP)
14184       {
14185          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
14186          break;
14187       }
14188
14189       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
14190
14191       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14192       if(f1apMsg->choice.successfulOutcome == NULLP)
14193       {
14194          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
14195          break;
14196       }
14197       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
14198       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
14199       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
14200
14201       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
14202
14203       if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
14204       {
14205          if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
14206             elementCnt =3;
14207          else
14208             elementCnt =2;
14209       }
14210       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14211          elementCnt = 5;
14212       if(ueCb->f1UeDb->actionType == UE_CTXT_RRC_RECFG_COMPLETE)
14213          elementCnt = 2;
14214       ueContextModifyRes->protocolIEs.list.count = elementCnt;
14215       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
14216
14217       /* Initialize the UE context modification members */
14218       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
14219       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
14220       {
14221          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
14222          break;
14223       }
14224
14225       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
14226       {
14227          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
14228          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
14229          {
14230             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
14231             break;
14232          }
14233       }
14234
14235       ieIdx=0;
14236       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14237       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14238       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
14239       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
14240       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
14241
14242       ieIdx++;
14243       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14244       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14245       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
14246       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
14247       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
14248
14249       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14250       {
14251          ieIdx++;
14252          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCInformation;
14253          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14254          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
14255          UEContextModificationResponseIEs__value_PR_DUtoCURRCInformation;
14256          BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
14257       }
14258
14259       if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || ((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbSetupMod)))
14260       {
14261          ieIdx++;
14262          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
14263          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14264          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
14265                                                                            UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
14266          if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14267          {
14268             for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
14269             {
14270                if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
14271                {
14272                   memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
14273                }
14274             }
14275          }
14276          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
14277                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
14278          if(ret != ROK)
14279          {
14280             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB setupmod List ");
14281             break;
14282          }
14283       }
14284
14285       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14286       {
14287          ieIdx++;
14288          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_SRBs_SetupMod_List;
14289          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14290          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
14291                                                                             UEContextModificationResponseIEs__value_PR_SRBs_SetupMod_List;
14292          for(rbIdx = 0; rbIdx < ueCb->rlcUeCfg.numLcs; rbIdx++)
14293          {
14294             if(ueCb->rlcUeCfg.rlcLcCfg[rbIdx].rbType == RB_TYPE_SRB)
14295             {
14296                memcpy(&ueCb->f1UeDb->duUeCfg.rlcLcCfg[ueCb->f1UeDb->duUeCfg.numRlcLcs++], &ueCb->rlcUeCfg.rlcLcCfg[rbIdx],\
14297                      sizeof(RlcBearerCfg));
14298             }
14299          }
14300          ret = BuildSrbSetupModList(&ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.SRBs_SetupMod_List, \
14301                &ueCb->f1UeDb->duUeCfg);
14302          if(ret != ROK)
14303          {
14304             DU_LOG( "\nERROR  -->  F1AP : Failed to build SRB setupmod List ");
14305             break;
14306          }
14307       }
14308
14309       freeF1UeDb(ueCb->f1UeDb);
14310       ueCb->f1UeDb = NULLP;
14311
14312       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14313
14314       /* Encode the F1SetupRequest type as APER */
14315       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14316       encBufSize = 0;
14317       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
14318
14319       /* Encode results */
14320       if(encRetVal.encoded == ENCODE_FAIL)
14321       {
14322          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
14323                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14324          ret = RFAILED;
14325          break;
14326       }
14327       else
14328       {
14329          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
14330          for(int i=0; i< encBufSize; i++)
14331          {
14332             printf("%x",encBuf[i]);
14333          }
14334       }
14335
14336       /* Sending  msg  */
14337       if(sendF1APMsg() != ROK)
14338       {
14339          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
14340          ret = RFAILED;
14341          break;
14342       }
14343
14344       ret = ROK;
14345       break;
14346    }
14347    FreeUeContextModResp(f1apMsg);
14348    return ret;
14349 }
14350 /*******************************************************************
14351  *
14352  * @brief Deallocating the memory allocated by the aper decoder
14353  *          for QOSInfo
14354  *
14355  * @details
14356  *
14357  *    Function : freeAperDecodeQosInfo
14358  *
14359  *    Functionality:  Deallocating the memory allocated for QOSInfo
14360  *
14361  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
14362  *
14363  * @return void
14364  *
14365  * ****************************************************************/
14366
14367 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
14368 {
14369    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
14370    {
14371       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
14372       {
14373          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
14374          {
14375             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
14376          }
14377          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
14378       }
14379       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
14380    }
14381 }
14382 /*******************************************************************
14383  *
14384  * @brief Deallocating the memory allocated by the aper decoder
14385  *          for UlTnlInfoforDrb
14386  *
14387  * @details
14388  *
14389  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
14390  *
14391  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
14392  *
14393  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
14394  *
14395  * @return void
14396  *
14397  * ****************************************************************/
14398 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
14399 {
14400    uint8_t arrIdx =0;
14401
14402    if(ulInfo->list.array)
14403    {
14404       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
14405       {
14406          if(ulInfo->list.array[arrIdx])
14407          {
14408             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
14409             {
14410                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
14411                {
14412                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
14413                   {
14414                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
14415                            gTP_TEID.buf);
14416                   }
14417                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
14418                         transportLayerAddress.buf);
14419                }
14420                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
14421             }
14422             free(ulInfo->list.array[arrIdx]);
14423          }
14424       }
14425       free(ulInfo->list.array);
14426    }
14427 }
14428 /*******************************************************************
14429  *
14430  * @brief Deallocating the memory allocated by the aper decoder
14431  *          for DrbSetupModItem
14432  *
14433  * @details
14434  *
14435  *    Function : freeAperDecodeDrbSetupModItem
14436  *
14437  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
14438  *
14439  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
14440  *
14441  * @return void
14442  *
14443  * ****************************************************************/
14444
14445 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
14446 {
14447    uint8_t arrIdx =0;
14448    SNSSAI_t *snssai =NULLP;
14449    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
14450
14451    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
14452    switch(drbItem->qoSInformation.present)
14453    {
14454       case QoSInformation_PR_NOTHING:
14455          break;
14456       case QoSInformation_PR_eUTRANQoS:
14457          {
14458             if(drbItem->qoSInformation.choice.eUTRANQoS)
14459             {
14460                free(drbItem->qoSInformation.choice.eUTRANQoS);
14461             }
14462             break;
14463          }
14464       case QoSInformation_PR_choice_extension:
14465          {
14466             if(drbItem->qoSInformation.choice.choice_extension)
14467             {
14468                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
14469                      DRB_Information.dRB_QoS);
14470                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
14471                if(snssai->sST.buf)
14472                {
14473                   free(snssai->sST.buf);
14474                }
14475                if(snssai->sD)
14476                {
14477                   if(snssai->sD->buf)
14478                   {
14479                      free(snssai->sD->buf);
14480                   }
14481                   free(snssai->sD);
14482                }
14483
14484                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
14485                          DRB_Information.flows_Mapped_To_DRB_List;
14486                if(flowMap->list.array)
14487                {
14488                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
14489                   {
14490                      if(flowMap->list.array[arrIdx] )
14491                      {
14492                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
14493                         free(flowMap->list.array[arrIdx]);
14494                      }
14495                   }
14496                   free(flowMap->list.array);
14497                }
14498
14499                free(drbItem->qoSInformation.choice.choice_extension);
14500             }
14501             break;
14502          }
14503
14504    }
14505    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
14506    if(drbItem->uLConfiguration)
14507    {
14508       free(drbItem->uLConfiguration);
14509    }
14510 }
14511
14512 /*******************************************************************
14513  *
14514  * @brief Deallocating the memory allocated by the aper decoder
14515  *          for DrbToBeSetupModList
14516  *
14517  * @details
14518  *
14519  *    Function : freeAperDecodeDrbToBeSetupModList
14520  *
14521  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
14522  *
14523  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
14524  *
14525  * @return void
14526  *
14527  * ****************************************************************/
14528
14529 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
14530 {
14531    uint8_t arrIdx =0;
14532    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
14533
14534    if(drbSet->list.array)
14535    {
14536       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
14537       {
14538          if(drbSet->list.array[arrIdx] != NULLP)
14539          {
14540             if(arrIdx == 0)
14541             {
14542                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
14543                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
14544             }
14545             free(drbSet->list.array[arrIdx]);
14546          }
14547       }
14548       free(drbSet->list.array);
14549    }
14550
14551 }
14552 /*******************************************************************
14553  *
14554  * @brief Deallocating the memory allocated by the aper decoder
14555  *          for UeContextModificationReqMsg
14556  *
14557  * @details
14558  *
14559  *    Function : freeAperDecodeUeContextModificationReqMsg
14560  *
14561  *    Functionality:  Deallocating memory allocated for
14562  *                  UeContextModificationReqMsg
14563  *
14564  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
14565  *
14566  * @return void
14567  *
14568  * ****************************************************************/
14569 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *ueContextModifyReq )
14570 {
14571    uint8_t arrIdx, ieId;
14572
14573    if(ueContextModifyReq->protocolIEs.list.array)
14574    {
14575       for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
14576       {
14577          if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
14578          {
14579             ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
14580             switch(ieId)
14581             {
14582                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14583                   break;
14584                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14585                   break;
14586                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
14587                   {
14588                      freeAperDecodeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
14589                            value.choice.DRBs_ToBeSetupMod_List);
14590                      break;
14591                   }
14592                case ProtocolIE_ID_id_TransmissionActionIndicator:
14593                   break;
14594                case ProtocolIE_ID_id_RRCContainer:
14595                   {
14596                      free(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf);
14597                   }
14598             }
14599             free(ueContextModifyReq->protocolIEs.list.array[arrIdx]);
14600          }
14601       }
14602       free(ueContextModifyReq->protocolIEs.list.array);
14603    }
14604 }
14605 /*******************************************************************
14606  *
14607  * @brief processing the F1 UeContextModificationReq
14608  *
14609  * @details
14610  *
14611  *    Function : procF1UeContextModificationReq
14612  *
14613  *    Functionality:  processing the F1 UeContextModificationReq
14614  *
14615  * @params[in] F1AP_PDU_t *f1apMsg
14616  *
14617  * @return
14618  * ****************************************************************/
14619 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
14620 {
14621    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
14622    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0;
14623    DuUeCb   *duUeCb = NULLP;
14624    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
14625    DRBs_ToBeModified_List_t *drbModifiedCfg;
14626    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
14627
14628    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
14629    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
14630    {
14631       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
14632       {
14633          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14634             {
14635                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
14636                break;
14637             }
14638          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14639             {
14640                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
14641                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
14642                {
14643                   if(duCb.actvCellLst[cellIdx])
14644                   {
14645                      if((duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == gnbDuUeF1apId)&&\
14646                            (duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbCuUeF1apId == gnbCuUeF1apId))
14647                      {
14648                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1];
14649                         if(duUeCb->f1UeDb == NULLP)
14650                         {
14651                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
14652                            duUeCb->f1UeDb->cellIdx = cellIdx;
14653                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
14654                         }
14655                         break;
14656                      }
14657                   }
14658                }
14659                if(duUeCb == NULLP)
14660                {
14661                   DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
14662                   ret = RFAILED;
14663                }
14664                break;
14665             }
14666
14667          case ProtocolIE_ID_id_RRCContainer:
14668             {
14669                /* Filling Dl RRC Msg Info */
14670                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
14671                if(!duUeCb->f1UeDb->dlRrcMsg)
14672                {
14673                   DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
14674                         Memory allocation failed ");
14675                   ret = RFAILED;
14676                }
14677                else
14678                {
14679                   duUeCb->f1UeDb->dlRrcMsgPres = true;
14680                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
14681                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
14682                         &ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
14683                         value.choice.RRCContainer);
14684                }
14685
14686                break;
14687             }
14688
14689          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
14690          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
14691             {
14692                if(duUeCb->f1UeDb)
14693                {
14694                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
14695                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
14696                   {
14697                      drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
14698                                       choice.DRBs_ToBeSetupMod_List;
14699
14700                      if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
14701                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
14702                      {
14703                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
14704                         ret = RFAILED;
14705                      }
14706                   }
14707
14708                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
14709                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
14710
14711                   {
14712                      drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
14713                                       choice.DRBs_ToBeModified_List;
14714                      if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
14715                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
14716                      {
14717                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
14718                         ret = RFAILED;
14719                      }
14720                   }
14721                }
14722                break;
14723             }
14724
14725          case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
14726             {
14727                DU_LOG("\nINFO  -->  DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
14728                if(duUeCb->f1UeDb)
14729                {
14730                   duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
14731                }
14732                break;
14733             }
14734
14735          case ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator:
14736             {
14737                if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator == \
14738                   RRCReconfigurationCompleteIndicator_true)
14739                {
14740                   duUeCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE;
14741                }
14742                break;
14743             }
14744          case ProtocolIE_ID_id_TransmissionActionIndicator:
14745             {
14746                if(duUeCb->f1UeDb)
14747                {
14748                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator  == TransmissionActionIndicator_stop)
14749                   {
14750                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = STOP_TRANSMISSION;
14751                   }
14752                   else
14753                   {
14754                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = RESTART_TRANSMISSION;
14755                   }
14756                }
14757                break;
14758             }
14759
14760          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
14761             {
14762                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
14763                {
14764                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
14765                }
14766                break;
14767             }
14768
14769       }
14770    }
14771
14772    if(ret != RFAILED)
14773    {
14774       ret = duProcUeContextModReq(duUeCb);
14775    }
14776    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
14777    return ret;
14778 }
14779
14780 /*****************************************************************i
14781 *
14782 * @brief Free memory allocated for UE Context Release Request
14783 *
14784 * @details
14785 *
14786 *    Function : FreeUeContextReleaseReq
14787 *
14788 *    Functionality:
14789 *         - Free memory allocated for UE Context Release Request
14790 *
14791 * @params[in] F1AP_PDU_t *f1apMsg
14792 * @return void
14793 *
14794 * *************************************************************/
14795 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
14796 {
14797    uint8_t ieIdx;
14798    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
14799
14800    if(f1apMsg)
14801    {
14802       if(f1apMsg->choice.initiatingMessage)
14803       {
14804          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
14805          if(ueReleaseReq->protocolIEs.list.array)
14806          {
14807             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
14808             {
14809                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
14810             }
14811             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
14812          }
14813          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14814       }
14815       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14816    }
14817
14818 }
14819 /*****************************************************************i
14820 *
14821 * @brief Build and Send UE Context Release Request
14822 *
14823 * @details
14824 *
14825 *    Function : BuildAndSendUeContextReleaseReq
14826 *
14827 *    Functionality:
14828 *         - Build and Send UE Context Release Request
14829 *
14830 * @params[in]
14831 * @return ROK     - success
14832 *         RFAILED - failure
14833 *
14834 * *************************************************************/
14835 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
14836 {
14837    bool memAllocFail = false;
14838    uint8_t ieIdx =0;
14839    uint8_t ret = RFAILED;
14840    uint16_t cellIdx =0;
14841    uint16_t crnti = 0;
14842    uint8_t  elementCnt = 0;
14843    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
14844    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
14845    asn_enc_rval_t encRetVal;
14846    F1AP_PDU_t *f1apMsg = NULLP;
14847    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
14848
14849    DU_LOG("\nINFO  --> Building the UE Context Release Request");
14850    do
14851    {
14852       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14853       if(f1apMsg == NULLP)
14854       {
14855          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
14856          break;
14857       }
14858
14859       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14860       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14861       if(f1apMsg->choice.initiatingMessage == NULLP)
14862       {
14863          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
14864          initiatingMessage");
14865          break;
14866       }
14867       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
14868       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
14869       f1apMsg->choice.initiatingMessage->value.present = \
14870       InitiatingMessage__value_PR_UEContextReleaseRequest;
14871
14872       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
14873
14874       elementCnt = 2;
14875
14876       ueReleaseReq->protocolIEs.list.count = elementCnt;
14877       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
14878
14879       /* Initialize the F1Setup members */
14880       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
14881       if(ueReleaseReq->protocolIEs.list.array == NULLP)
14882       {
14883          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
14884          break;
14885       }
14886       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
14887       {
14888          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
14889                sizeof(UEContextReleaseRequest_t));
14890          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
14891          {
14892             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
14893             memAllocFail = true;
14894             break;
14895          }
14896       }
14897       if(memAllocFail == true)
14898          break;
14899
14900       /* Fetching Ue Cb Info*/
14901       GET_CELL_IDX(cellId, cellIdx);
14902       if(duCb.actvCellLst[cellIdx] == NULLP)
14903       {
14904          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
14905          break;
14906       }
14907       else
14908       {
14909          GET_CRNTI(crnti, ueId);
14910          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
14911          {
14912             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
14913             break;
14914          }
14915          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
14916          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
14917       }
14918
14919       ieIdx=0;
14920       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14921       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
14922       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
14923       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
14924       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
14925
14926       ieIdx++;
14927       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14928       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
14929       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
14930       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
14931       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
14932
14933       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14934
14935       /* Encode the F1SetupRequest type as APER */
14936       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14937       encBufSize = 0;
14938       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
14939       /* Encode results */
14940       if(encRetVal.encoded == ENCODE_FAIL)
14941       {
14942          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
14943                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14944          break;
14945       }
14946       else
14947       {
14948          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
14949          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
14950          {
14951             printf("%x",encBuf[ieIdx]);
14952          }
14953       }
14954
14955       /* Sending msg */
14956       if(sendF1APMsg() != ROK)
14957       {
14958          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
14959          break;
14960       }
14961       ret = ROK;
14962       break;
14963    }while(true);
14964
14965    FreeUeContextReleaseReq(f1apMsg);
14966    return ret;
14967 }
14968 /*****************************************************************i
14969  *
14970  * @brief Free memory allocated for UE Context Release Complete
14971  *
14972  * @details
14973  *
14974  *    Function : FreeUeContextReleaseComplete
14975  *
14976  *    Functionality:
14977  *         - Free memory allocated for UE Context Release Complete
14978  *
14979  * @params[in] F1AP_PDU_t *f1apMsg
14980  * @return void
14981  *
14982  * *************************************************************/
14983 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
14984 {
14985    uint8_t ieIdx;
14986    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
14987
14988    if(f1apMsg)
14989    {
14990       if(f1apMsg->choice.successfulOutcome)
14991       {
14992          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
14993          if(ueReleaseComplete->protocolIEs.list.array)
14994          {
14995             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
14996             {
14997                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
14998             }
14999             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
15000          }
15001          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15002       }
15003       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
15004    }
15005
15006 }
15007 /*****************************************************************i
15008  *
15009  * @brief Build and Send UE Context Release Complete
15010  *
15011  * @details
15012  *
15013  *    Function : BuildAndSendUeContextReleaseComplete
15014  *
15015  *    Functionality:
15016  *         - Build and Send UE Context Release Complete
15017  *
15018  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
15019  * @return ROK     - success
15020  *         RFAILED - failure
15021  *
15022  * *************************************************************/
15023 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
15024 {
15025    bool memAllocFail = false;
15026    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
15027    asn_enc_rval_t encRetVal;
15028    F1AP_PDU_t *f1apMsg = NULLP;
15029    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
15030
15031    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
15032    do
15033    {
15034       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
15035       if(f1apMsg == NULLP)
15036       {
15037          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
15038          break;
15039       }
15040
15041       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
15042       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15043       if(f1apMsg->choice.successfulOutcome == NULLP)
15044       {
15045          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
15046                successfulOutcome");
15047          break;
15048       }
15049       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
15050       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
15051       f1apMsg->choice.successfulOutcome->value.present = \
15052       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
15053
15054       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
15055
15056       elementCnt = 2;
15057       ueReleaseComplete->protocolIEs.list.count = elementCnt;
15058       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
15059
15060       /* Initialize the UE Release Complete members */
15061       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
15062       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
15063       {
15064          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
15065          break;
15066       }
15067       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
15068       {
15069          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
15070                sizeof(UEContextReleaseComplete_t));
15071          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
15072          {
15073             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
15074             elements");
15075             memAllocFail = true;
15076             break;
15077          }
15078       }
15079       if(memAllocFail == true)
15080          break;
15081
15082
15083       ieIdx=0;
15084       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
15085       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
15086       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
15087       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
15088       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
15089
15090       ieIdx++;
15091       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
15092       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
15093       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
15094       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
15095       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
15096
15097       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15098
15099       /* Encode the F1SetupComplete type as APER */
15100       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15101       encBufSize = 0;
15102       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
15103       /* Encode results */
15104       if(encRetVal.encoded == ENCODE_FAIL)
15105       {
15106          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
15107                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15108          break;
15109       }
15110       else
15111       {
15112          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
15113          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
15114          {
15115             printf("%x",encBuf[ieIdx]);
15116          }
15117       }
15118
15119       /* Sending msg */
15120       if(sendF1APMsg() != ROK)
15121       {
15122          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
15123          break;
15124       }
15125       ret = ROK;
15126       break;
15127    }while(true);
15128
15129    if((ret == ROK) && (duCb.actvCellLst[cellId-1]) && (duCb.actvCellLst[cellId-1]->cellStatus == DELETION_IN_PROGRESS)
15130          && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
15131    {
15132       ret = duSendCellDeletReq(cellId);
15133       if(ret != ROK)
15134       {
15135          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
15136                Delete req for CellId");
15137       }
15138    }
15139    FreeUeContextReleaseComplete(f1apMsg);
15140    return ret;
15141
15142 }
15143
15144 /*******************************************************************
15145 *
15146 * @brief added free part for the memory allocated by aper_decoder
15147 *
15148 * @details
15149 *
15150 *    Function : freeAperDecodeUeContextReleaseCommand
15151 *
15152 *    Functionality: added free part for the memory allocated by aper_decoder
15153 *
15154 * @params[in] F1AP_PDU_t *f1apMsg
15155 * @return void
15156 *
15157 * ****************************************************************/
15158 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
15159 {
15160    uint8_t ieIdx=0;
15161    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
15162
15163    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
15164
15165    if(ueContextReleaseCommand->protocolIEs.list.array)
15166    {
15167       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
15168       {
15169          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
15170          {
15171             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
15172             {
15173                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15174                   break;
15175                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15176                   break;
15177                case ProtocolIE_ID_id_Cause:
15178                   break;
15179                case ProtocolIE_ID_id_RRCContainer:
15180                {
15181                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
15182                   {
15183                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
15184                   }
15185                   break;
15186                }
15187                default :
15188                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
15189                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
15190                   break;
15191             }
15192          }
15193          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
15194       }
15195       free(ueContextReleaseCommand->protocolIEs.list.array);
15196    }
15197 }
15198 /*******************************************************************
15199 *
15200 * @brief processing of UE Context Release Command
15201 *
15202 * @details
15203 *
15204 *    Function : procF1UeContextReleaseCommand
15205 *
15206 *    Functionality: processing of UE Context Release Command
15207 *
15208 * @params[in] F1AP_PDU_t *f1apMsg
15209 * @return void
15210 *
15211 * ****************************************************************/
15212 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
15213 {
15214    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
15215    uint16_t cellIdx =0, cellId = 0;
15216    bool ueIdxFound = false;
15217    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
15218    DuUeCb   *duUeCb = NULLP;
15219    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
15220
15221    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
15222
15223    if(ueContextReleaseCommand->protocolIEs.list.array)
15224    {
15225       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
15226       {
15227          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
15228          {
15229             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
15230             {
15231                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15232                   {
15233                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
15234                                     value.choice.GNB_CU_UE_F1AP_ID;
15235                      break;
15236                   }
15237
15238                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15239                   {
15240                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
15241                                      value.choice.GNB_DU_UE_F1AP_ID;
15242                      break;
15243                   }
15244
15245                case ProtocolIE_ID_id_Cause:
15246                   {
15247                      for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
15248                      {
15249                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
15250                         {
15251                            if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
15252                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
15253                            {
15254                               cellId = duCb.actvCellLst[cellIdx]->cellId;
15255                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
15256                               ueIdxFound = true;
15257                               break;
15258                            }
15259                         }
15260                         if(ueIdxFound == true)
15261                         {
15262                            break;
15263                         }
15264                      }
15265
15266                      if(!ueIdxFound)
15267                      {
15268                         DU_LOG("\nERROR  -->  F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
15269                         ret = RFAILED;
15270                      }
15271                      break;
15272                   }
15273
15274                case ProtocolIE_ID_id_RRCContainer:
15275                   {
15276                      if(ueIdxFound == true)
15277                      {
15278                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
15279                         if(duUeCb->f1UeDb)
15280                         {
15281                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
15282                            duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
15283                            duUeCb->f1UeDb->cellIdx = cellIdx;
15284                            /* Filling Dl RRC Msg Info */
15285                            DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
15286                            if(!duUeCb->f1UeDb->dlRrcMsg)
15287                            {
15288                               DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
15289                                     Memory allocation failed ");
15290                               ret = RFAILED;
15291                            }
15292                            else
15293                            {
15294                               duUeCb->f1UeDb->dlRrcMsgPres = true;
15295                               memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
15296                               ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
15297                                     &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
15298                                     value.choice.RRCContainer);
15299                            }
15300
15301                         }
15302                         else
15303                         {
15304                            DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
15305                                  Memory allocation failed ");
15306                            ret = RFAILED;
15307
15308                         }
15309                      }
15310                      break;
15311                   }
15312                default :
15313                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
15314                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
15315                   break;
15316             }
15317          }
15318       }
15319    }
15320    if(ret != RFAILED)
15321    {
15322       duProcUeContextReleaseCommand(cellId, duUeCb);
15323    }
15324    freeAperDecodeUeContextReleaseCommand(f1apMsg);
15325    return ret;
15326 }
15327
15328 /**************************************************************
15329  *
15330  * @brief free the memory allocated by aper decoder for paging
15331  *
15332  * @details
15333  *
15334  *    Function : freeAperDecodePagingMsg
15335  *
15336  *    Functionality:
15337  *         - free the memory allocated by aper decoder for
15338  *         the paging f1ap msg
15339  *
15340  * @params[in] Paging_t   *paging
15341  * @return ROK     - success
15342  *         RFAILED - failure
15343  *
15344  ****************************************************************/
15345 void freeAperDecodePagingMsg(Paging_t   *paging)
15346 {
15347    uint8_t ieIdx, cellIdx;
15348    PagingCell_ItemIEs_t *pagingCellItemIes;
15349    PagingCell_Item_t *pagingCellItem;
15350    PagingCell_list_t  *pagingCelllist;
15351
15352    if(paging)
15353    {
15354       if(paging->protocolIEs.list.array)
15355       {
15356          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
15357          {
15358             if(paging->protocolIEs.list.array[ieIdx])
15359             {
15360                switch(paging->protocolIEs.list.array[ieIdx]->id)
15361                {
15362                   case ProtocolIE_ID_id_UEIdentityIndexValue:
15363                      {
15364                         free(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf);
15365                         break;
15366                      }
15367                   case ProtocolIE_ID_id_PagingIdentity:
15368                      {
15369                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
15370                         {
15371                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
15372                            {
15373                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == \
15374                                     CNUEPagingIdentity_PR_fiveG_S_TMSI)
15375                               {
15376                                  free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf);
15377                               }
15378                               free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity);
15379                            }
15380                         }
15381                         break;
15382                      }
15383                   case ProtocolIE_ID_id_PagingCell_List:
15384                      {
15385                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
15386                         if(pagingCelllist->list.array)
15387                         {
15388                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
15389                            {
15390                               if(pagingCelllist->list.array[cellIdx])
15391                               {
15392                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
15393                                  if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
15394                                  {
15395                                     pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
15396                                     free(pagingCellItem->nRCGI.pLMN_Identity.buf);
15397                                     free(pagingCellItem->nRCGI.nRCellIdentity.buf);
15398                                  }
15399                                  free(pagingCelllist->list.array[cellIdx]);
15400                               }
15401                            }
15402                            free(pagingCelllist->list.array);
15403                         }
15404                         break;
15405                      }
15406                }
15407                free(paging->protocolIEs.list.array[ieIdx]);
15408             }
15409          }
15410          free(paging->protocolIEs.list.array);
15411
15412       }
15413    }
15414 }
15415
15416 /**************************************************************
15417  *
15418  * @brief processing the paging f1ap msg received from CU
15419  *
15420  * @details
15421  *
15422  *    Function : procPagingMsg
15423  *
15424  *    Functionality:
15425  *         - processing the paging f1ap msg received from CU
15426  *
15427  * @params[in] F1AP_PDU_t *f1apMsg
15428  * @return ROK     - success
15429  *         RFAILED - failure
15430  *
15431  *
15432  ****************************************************************/
15433 uint8_t procPagingMsg(F1AP_PDU_t *f1apMsg)
15434 {
15435    uint8_t ieIdx = 0, cellListIdx = 0;
15436    uint16_t cellId = 0, cellIdx = 0;
15437    Paging_t   *paging = NULLP;
15438    PagingCell_list_t  *pagingCelllist = NULLP;
15439    PagingCell_ItemIEs_t *pagingCellItemIes = NULLP;
15440    PagingCell_Item_t *pagingCellItem = NULLP;
15441    DuPagingMsg *tmpPagingParam = NULLP;
15442
15443    DU_LOG("\nINFO  --> DU APP : Processing the Paging Message");
15444    paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
15445    if(paging)
15446    {
15447       if(paging->protocolIEs.list.array)
15448       {
15449          DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg));
15450          if(tmpPagingParam == NULLP)
15451          {
15452             DU_LOG("\nERROR  --> DU APP : Memory Allocation Failure in procPagingMsg");
15453             freeAperDecodePagingMsg(paging);
15454             return RFAILED;
15455          }
15456          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
15457          {
15458             if(paging->protocolIEs.list.array[ieIdx])
15459             {
15460                switch(paging->protocolIEs.list.array[ieIdx]->id)
15461                {
15462                   case ProtocolIE_ID_id_UEIdentityIndexValue:
15463                      {
15464                         bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10,\
15465                                          &tmpPagingParam->ueId);
15466                         break;
15467                      }
15468
15469                   case ProtocolIE_ID_id_PagingIdentity:
15470                      {
15471                         switch(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present)
15472                         {
15473                            case PagingIdentity_PR_cNUEPagingIdentity:
15474                               {
15475                                  if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
15476                                  {
15477                                     bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.\
15478                                           cNUEPagingIdentity->choice.fiveG_S_TMSI, &tmpPagingParam->sTmsi);
15479
15480                                  }
15481                                  break;
15482                               }
15483                             case PagingIdentity_PR_rANUEPagingIdentity:
15484                                {
15485                                   /*TODO: This Identifier is specific to RAN Initiated Paging – Connected Mode Paging*/
15486                                   break;
15487                                }
15488                             default:
15489                                {
15490                                   DU_LOG("ERROR  -->  DU APP: Invalid UE Paging Identity, Skipping this Paging Message:");
15491                                   continue;
15492                                }
15493                         }
15494                      }
15495
15496                   case ProtocolIE_ID_id_PagingDRX:
15497                      {
15498                         tmpPagingParam->pagingDrxPres = TRUE;
15499                         tmpPagingParam->pagingDrx = convertPagingCycleEnumToValue(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX);
15500                         break;
15501                      }
15502
15503                   case ProtocolIE_ID_id_PagingPriority:
15504                      {
15505                         tmpPagingParam->pagPriority = paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority;
15506                         break;
15507                      }
15508
15509                   case ProtocolIE_ID_id_PagingCell_List:
15510                      {
15511                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
15512                         if(pagingCelllist->list.array)
15513                         {
15514                            for(cellListIdx = 0; cellListIdx < pagingCelllist->list.count; cellListIdx++)
15515                            {
15516                               if(pagingCelllist->list.array[cellListIdx])
15517                               {
15518                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellListIdx];
15519                                  pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
15520                                  bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId);
15521                                  GET_CELL_IDX(cellId, cellIdx);
15522                                  if(duCb.actvCellLst[cellIdx])
15523                                  {
15524                                     /* fill Ue Paging information*/
15525                                     if(FillPagingInfoInCellCb(duCb.actvCellLst[cellIdx], tmpPagingParam)!= ROK)
15526                                     {
15527                                        DU_LOG("\nERROR  --> DU APP : CellCb:%d not present to fill UE Paging Information",cellIdx);
15528                                        continue;
15529                                     }
15530                                  }
15531                                  else
15532                                  {
15533                                     DU_LOG("\nERROR  --> F1AP : CellId:%d Not in Activelist",cellId);
15534                                     continue;
15535                                  }
15536                               }
15537                            }
15538                         }
15539                         break;
15540                      }
15541                    default:
15542                      {
15543                          DU_LOG("\nERROR  --> F1AP : Incorrect Paging IE option");
15544                          break;
15545                      }
15546                }
15547             }
15548          }
15549       }
15550    }
15551    DU_FREE(tmpPagingParam, sizeof(DuPagingMsg));
15552    freeAperDecodePagingMsg(paging);
15553
15554    return ROK;
15555 }
15556
15557 /**************************************************************
15558  *
15559  * @brief Handles received F1AP message and sends back response
15560  *
15561  * @details
15562  *
15563  *    Function : F1APMsgHdlr
15564  *
15565  *    Functionality:
15566  *         - Decodes received F1AP control message
15567  *         - Prepares response message, encodes and sends to SCTP
15568  *
15569  * @params[in]
15570  * @return ROK     - success
15571  *         RFAILED - failure
15572  *
15573  * ****************************************************************/
15574 void F1APMsgHdlr(Buffer *mBuf)
15575 {
15576    int i =0;
15577    char *recvBuf =NULLP;
15578    MsgLen copyCnt =0;
15579    MsgLen recvBufLen =0;
15580    F1AP_PDU_t *f1apMsg =NULLP;
15581    asn_dec_rval_t rval; /* Decoder return value */
15582    F1AP_PDU_t f1apasnmsg ;
15583    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
15584    ODU_PRINT_MSG(mBuf, 0,0);
15585
15586    /* Copy mBuf into char array to decode it */
15587    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
15588    DU_ALLOC(recvBuf, (Size)recvBufLen);
15589
15590    if(recvBuf == NULLP)
15591    {
15592       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
15593       return;
15594    }
15595    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
15596    {
15597       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
15598       return;
15599    }
15600
15601    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
15602    for(i=0; i< recvBufLen; i++)
15603    {
15604       printf("%x",recvBuf[i]);
15605    }
15606
15607    /* Decoding flat buffer into F1AP messsage */
15608    f1apMsg = &f1apasnmsg;
15609    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
15610
15611    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
15612
15613    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
15614    {
15615       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
15616       return;
15617    }
15618    printf("\n");
15619    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15620
15621    switch(f1apMsg->present)
15622    {
15623       case F1AP_PDU_PR_successfulOutcome:
15624          {
15625             switch(f1apMsg->choice.successfulOutcome->value.present)
15626             {
15627                case SuccessfulOutcome__value_PR_ResetAcknowledge:
15628                   {
15629                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
15630                      break;
15631                   }
15632                case SuccessfulOutcome__value_PR_F1SetupResponse:
15633                   {
15634 #ifndef ODU_TEST_STUB
15635                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
15636 #endif
15637                      break;
15638                   }
15639
15640                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
15641                   {
15642                      procF1GNBDUCfgUpdAck(f1apMsg);
15643                      break;
15644                   }
15645
15646                default:
15647                   {
15648                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
15649                            f1apMsg->choice.successfulOutcome->value.present);
15650                      return;
15651                   }
15652             }/* End of switch(successfulOutcome) */
15653             free(f1apMsg->choice.successfulOutcome);
15654             break;
15655          }
15656       case F1AP_PDU_PR_initiatingMessage:
15657          {
15658             switch(f1apMsg->choice.initiatingMessage->value.present)
15659             {
15660                case InitiatingMessage__value_PR_Reset:
15661                   {
15662                      procF1ResetReq(f1apMsg);
15663                      break;
15664                   }
15665                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
15666                   {
15667                      procF1DlRrcMsgTrans(f1apMsg);
15668                      break;
15669                   }
15670                case InitiatingMessage__value_PR_UEContextSetupRequest:
15671                   {
15672                      procF1UeContextSetupReq(f1apMsg);
15673                      break;
15674                   }
15675                case InitiatingMessage__value_PR_UEContextModificationRequest:
15676                   {
15677                      procF1UeContextModificationReq(f1apMsg);
15678                      break;
15679                   }
15680                case InitiatingMessage__value_PR_UEContextReleaseCommand:
15681                   {
15682                       procF1UeContextReleaseCommand(f1apMsg);
15683                       break;
15684                   }
15685                case InitiatingMessage__value_PR_Paging:
15686                   {
15687                      procPagingMsg(f1apMsg);
15688                      break;
15689                   }
15690                default:
15691                   {
15692                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
15693                            f1apMsg->choice.initiatingMessage->value.present);
15694                      return;
15695                   }
15696             }/* End of switch(initiatingMessage) */
15697             free(f1apMsg->choice.initiatingMessage);
15698             break;
15699          }
15700
15701       default:
15702          {
15703             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
15704             return;
15705          }
15706          free(f1apMsg);
15707
15708    }/* End of switch(f1apMsg->present) */
15709
15710    DU_FREE(recvBuf, (Size)recvBufLen);
15711 } /* End of F1APMsgHdlr */
15712
15713 /**********************************************************************
15714   End of file
15715  **********************************************************************/