src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "BWP-UplinkDedicated.h"
  75 #include "PUSCH-ServingCellConfig.h"
  76 #include "UplinkConfig.h"
  77 #include "DUtoCURRCContainer.h"
  78 #include "GBR-QoSFlowInformation.h"
  79 #include "QoSFlowLevelQoSParameters.h"
  80 #include "PUCCH-Config.h"
  81 #include "PUCCH-ResourceSet.h"
  82 #include "PUCCH-Resource.h"
  83 #include "PUCCH-PowerControl.h"
  84 #include "P0-PUCCH.h"
  85 #include "PUCCH-PathlossReferenceRS.h"
  86 #include "PUCCH-format0.h"
  87 #include "PUCCH-format1.h"
  88 #include "PUCCH-format2.h"
  89 #include "PUCCH-format3.h"
  90 #include "PUCCH-format4.h"
  91 #include "PUCCH-FormatConfig.h"
  92 #include "SchedulingRequestResourceConfig.h"
  93 #include<ProtocolIE-Field.h>
  94 #include "ProtocolExtensionField.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104 #include "SupportedSULFreqBandItem.h"
 105 #include "du_sys_info_hdl.h"
 106
 107 #ifdef O1_ENABLE
 108 #include "CmInterface.h"
 109 extern StartupConfig g_cfg;
 110 #endif
 111
 112 DuCfgParams duCfgParam;
 113
 114 /******************************************************************
 115  *
 116  * @brief Function to fetch lcId based on DRB Id
 117  *
 118  * @details
 119  *
 120  *    Function : fetchLcId
 121  *
 122  *    @params[in] drbId
 123  *
 124  *    Functionality: Function to fetch lcId based on DRB Id
 125  *
 126  * Returns: lcId - SUCCESS
 127  *          RFAILED - FAILURE
 128  *****************************************************************/
 129
 130 uint8_t fetchLcId(uint8_t drbId)
 131 {
 132    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 133
 134    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 135    {
 136       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 137       {
 138          if(duCb.actvCellLst[cellIdx] != NULLP)
 139          {
 140             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.numLcs;
 141             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 142             {
 143                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbId == drbId && \
 144                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbType == RB_TYPE_DRB)
 145                {
 146                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].lcId;
 147                   return lcId;
 148                }
 149             }
 150          }
 151       }
 152    }
 153    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 154    return RFAILED;
 155 }
 156
 157 /************************************************************************
 158  *
 159  * @brief Converts enum values into actual value of Poll retransmit timer
 160  *
 161  * @details
 162  *
 163  *    Function : getPollPdu
 164  *
 165  *    Functionality: Converts enum values into actual value of poll
 166  *    retransmit timer
 167  *
 168  * @params[in] Enum value of pollPdu
 169  * @return Actual value of pollPdu
 170  *
 171  * **********************************************************************/
 172
 173 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 174 {
 175    uint16_t pollRetxTmr;
 176
 177    /* All values of poll retx timer are at interval of 5ms.
 178     * This is valid upto 250ms
 179     * Hence converting the enum value to actual value by multiplying it to 5
 180     */
 181    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 182       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 183    else
 184    {
 185       switch(pollRetxTmrCfg)
 186       {
 187          case T_PollRetransmit_ms300:
 188             pollRetxTmr = 300;
 189             break;
 190          case T_PollRetransmit_ms350:
 191             pollRetxTmr = 350;
 192             break;
 193          case T_PollRetransmit_ms400:
 194             pollRetxTmr = 400;
 195             break;
 196          case T_PollRetransmit_ms450:
 197             pollRetxTmr = 450;
 198             break;
 199          case T_PollRetransmit_ms500:
 200             pollRetxTmr = 500;
 201             break;
 202          case T_PollRetransmit_ms800:
 203             pollRetxTmr = 800;
 204             break;
 205          default:
 206             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 207             pollRetxTmr = 0;
 208       }
 209    }
 210    return pollRetxTmr;
 211 }
 212
 213 /*******************************************************************
 214  *
 215  * @brief Converts enum values into actual value of PollPdu
 216  *
 217  * @details
 218  *
 219  *    Function : getPollPdu
 220  *
 221  *    Functionality: Converts enum values into actual value of PollPdu
 222  *
 223  * @params[in] Enum value of pollPdu
 224  * @return Actual value of pollPdu
 225  *
 226  * ****************************************************************/
 227 int32_t getPollPdu(uint8_t pollPduCfg)
 228 {
 229    int32_t pollPdu;
 230    switch(pollPduCfg)
 231    {
 232       case PollPDU_p4:
 233          pollPdu = 4;
 234          break;
 235       case PollPDU_p8:
 236          pollPdu = 8;
 237          break;
 238       case PollPDU_p16:
 239          pollPdu = 16;
 240          break;
 241       case PollPDU_p32:
 242          pollPdu = 32;
 243          break;
 244       case PollPDU_p64:
 245          pollPdu = 64;
 246          break;
 247       case PollPDU_p128:
 248          pollPdu = 128;
 249          break;
 250       case PollPDU_p256:
 251          pollPdu = 256;
 252          break;
 253       case PollPDU_p512:
 254          pollPdu = 512;
 255          break;
 256       case PollPDU_p1024:
 257          pollPdu = 1024;
 258          break;
 259       case PollPDU_p2048:
 260          pollPdu = 2048;
 261          break;
 262       case PollPDU_p4096:
 263          pollPdu = 4096;
 264          break;
 265       case PollPDU_p6144:
 266          pollPdu = 6144;
 267          break;
 268       case PollPDU_p8192:
 269          pollPdu = 8192;
 270          break;
 271       case PollPDU_p12288:
 272          pollPdu = 12288;
 273          break;
 274       case PollPDU_p16384:
 275          pollPdu = 16384;
 276          break;
 277       case PollPDU_p20480:
 278          pollPdu = 20480;
 279          break;
 280       case PollPDU_p24576:
 281          pollPdu = 24576;
 282          break;
 283       case PollPDU_p28672:
 284          pollPdu = 28672;
 285          break;
 286       case PollPDU_p32768:
 287          pollPdu = 32768;
 288          break;
 289       case PollPDU_p40960:
 290          pollPdu = 40960;
 291          break;
 292       case PollPDU_p49152:
 293          pollPdu = 49152;
 294          break;
 295       case PollPDU_p57344:
 296          pollPdu = 57344;
 297          break;
 298       case PollPDU_p65536:
 299          pollPdu = 65536;
 300          break;
 301       case PollPDU_infinity:
 302          pollPdu = -1;
 303          break;
 304       default:
 305          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 306          pollPdu = 0;
 307          break;
 308    }
 309    return pollPdu;
 310 }
 311
 312 /*******************************************************************
 313  *
 314  * @brief Converts enum values into actual value of poll bytes
 315  *
 316  * @details
 317  *
 318  *    Function : getPollByte
 319  *
 320  *    Functionality: Converts enum values into actual value of pollBytes
 321  *
 322  * @params[in] Enum value
 323  * @return Actual value
 324  *
 325  * ****************************************************************/
 326 int32_t getPollByte(uint16_t pollBytesCfg)
 327 {
 328    int32_t pollBytes;
 329    switch(pollBytesCfg)
 330    {
 331       case PollByte_kB1:
 332          pollBytes = 1000;
 333          break;
 334       case PollByte_kB2:
 335          pollBytes = 2000;
 336          break;
 337       case PollByte_kB5:
 338          pollBytes = 5000;
 339          break;
 340       case PollByte_kB8:
 341          pollBytes = 8000;
 342          break;
 343       case PollByte_kB10:
 344          pollBytes = 10000;
 345          break;
 346       case PollByte_kB15:
 347          pollBytes = 15000;
 348          break;
 349       case PollByte_kB25:
 350          pollBytes = 25000;
 351          break;
 352       case PollByte_kB50:
 353          pollBytes = 50000;
 354          break;
 355       case PollByte_kB75:
 356          pollBytes = 75000;
 357          break;
 358       case PollByte_kB100:
 359          pollBytes = 100000;
 360          break;
 361       case PollByte_kB125:
 362          pollBytes = 125000;
 363          break;
 364       case PollByte_kB250:
 365          pollBytes = 250000;
 366          break;
 367       case PollByte_kB375:
 368          pollBytes = 375000;
 369          break;
 370       case PollByte_kB500:
 371          pollBytes = 500000;
 372          break;
 373       case PollByte_kB750:
 374          pollBytes = 750000;
 375          break;
 376       case PollByte_kB1000:
 377          pollBytes = 1000000;
 378          break;
 379       case PollByte_kB1250:
 380          pollBytes = 1250000;
 381          break;
 382       case PollByte_kB1500:
 383          pollBytes = 1500000;
 384          break;
 385       case PollByte_kB2000:
 386          pollBytes = 2000000;
 387          break;
 388       case PollByte_kB3000:
 389          pollBytes = 3000000;
 390          break;
 391       case PollByte_kB4000:
 392          pollBytes = 4000000;
 393          break;
 394       case PollByte_kB4500:
 395          pollBytes = 4500000;
 396          break;
 397       case PollByte_kB5000:
 398          pollBytes = 5000000;
 399          break;
 400       case PollByte_kB5500:
 401          pollBytes = 5500000;
 402          break;
 403       case PollByte_kB6000:
 404          pollBytes = 6000000;
 405          break;
 406       case PollByte_kB6500:
 407          pollBytes = 6500000;
 408          break;
 409       case PollByte_kB7000:
 410          pollBytes = 7000000;
 411          break;
 412       case PollByte_kB7500:
 413          pollBytes = 7500000;
 414          break;
 415       case PollByte_mB8:
 416          pollBytes = 8000000;
 417          break;
 418       case PollByte_mB9:
 419          pollBytes = 9000000;
 420          break;
 421       case PollByte_mB10:
 422          pollBytes = 10000000;
 423          break;
 424       case PollByte_mB11:
 425          pollBytes = 11000000;
 426          break;
 427       case PollByte_mB12:
 428          pollBytes = 12000000;
 429          break;
 430       case PollByte_mB13:
 431          pollBytes = 13000000;
 432          break;
 433       case PollByte_mB14:
 434          pollBytes = 14000000;
 435          break;
 436       case PollByte_mB15:
 437          pollBytes = 15000000;
 438          break;
 439       case PollByte_mB16:
 440          pollBytes = 16000000;
 441          break;
 442       case PollByte_mB17:
 443          pollBytes = 17000000;
 444          break;
 445       case PollByte_mB18:
 446          pollBytes = 18000000;
 447          break;
 448       case PollByte_mB20:
 449          pollBytes = 20000000;
 450          break;
 451       case PollByte_mB25:
 452          pollBytes = 25000000;
 453          break;
 454       case PollByte_mB30:
 455          pollBytes = 30000000;
 456          break;
 457       case PollByte_mB40:
 458          pollBytes = 40000000;
 459          break;
 460       case PollByte_infinity:
 461          pollBytes = -1;
 462          break;
 463       default:
 464          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 465          pollBytes = 0;
 466    }
 467    return pollBytes;
 468 }
 469
 470 /*******************************************************************
 471  *
 472  * @brief Converts enum values into actual value of maxRetx
 473  *
 474  * @details
 475  *
 476  *    Function : getMaxRetx
 477  *
 478  *    Functionality: Converts enum values into actual value of maxRetx
 479  *
 480  * @params[in] Enum value
 481  * @return Actual value
 482  *
 483  * ****************************************************************/
 484 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 485 {
 486    uint8_t maxRetx;
 487    switch(maxRetxCfg)
 488    {
 489       case UL_AM_RLC__maxRetxThreshold_t1:
 490          maxRetx = 1;
 491          break;
 492       case UL_AM_RLC__maxRetxThreshold_t2:
 493          maxRetx = 2;
 494          break;
 495       case UL_AM_RLC__maxRetxThreshold_t3:
 496          maxRetx = 3;
 497          break;
 498       case UL_AM_RLC__maxRetxThreshold_t4:
 499          maxRetx = 4;
 500          break;
 501       case UL_AM_RLC__maxRetxThreshold_t6:
 502          maxRetx = 6;
 503          break;
 504       case UL_AM_RLC__maxRetxThreshold_t8:
 505          maxRetx = 8;
 506          break;
 507       case UL_AM_RLC__maxRetxThreshold_t16:
 508          maxRetx = 16;
 509          break;
 510       case UL_AM_RLC__maxRetxThreshold_t32:
 511          maxRetx = 32;
 512          break;
 513       default:
 514          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 515          maxRetx = 0;
 516    }
 517    return maxRetx;
 518 }
 519
 520 /*******************************************************************
 521  * @brief Converts enum values into actual value of reassembly timer
 522  *
 523  * @details
 524  *
 525  *    Function : getReAsmblTmr
 526  *
 527  *    Functionality: Converts enum values into actual value of reassembly
 528  *    timer
 529  *
 530  * @params[in] Enum value of reassembly timer
 531  * @return Actual value of reassembly timer
 532  *
 533  * **********************************************************************/
 534
 535 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 536 {
 537    int8_t reAsmblTmr = 0;
 538
 539    if(reAsmblTmrCfg == T_Reassembly_ms0)
 540    {
 541       reAsmblTmr = 0;
 542    }
 543    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 544    {
 545      /* All values of re assembly timer are at interval of 5ms.
 546       * This is valid upto 100ms
 547       * Hence converting the enum value to actual value by multiplying it to 5
 548       */
 549       reAsmblTmr = reAsmblTmrCfg * 5;
 550    }
 551    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 552    {
 553      /* All values of re assembly timer are at interval of 10ms.
 554       * This is valid upto 200ms
 555       * since enum value starts from 20 for 100ms, subtracting 10 and
 556       * converting the enum value to actual value by multiplying it to 10
 557       */
 558       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 559    }
 560    else
 561    {
 562       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 563       reAsmblTmr = -1;
 564    }
 565    return reAsmblTmr;
 566 }
 567
 568 /************************************************************************
 569  *
 570  * @brief Converts enum values into actual value of status prohibit timer
 571  *
 572  * @details
 573  *
 574  *    Function : getStatProhTmr
 575  *
 576  *    Functionality: Converts enum values into actual value of status prohibit
 577  *    timer
 578  *
 579  * @params[in] Enum value of status prohibit timer
 580  * @return Actual value of status prohibit timer
 581  *
 582  * **********************************************************************/
 583
 584 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 585 {
 586    int16_t statProhTmr =0;
 587
 588    if(statProhTmrCfg == T_StatusProhibit_ms0)
 589    {
 590       statProhTmr = 0;
 591    }
 592    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 593    {
 594       /* All values of re assembly timer are at interval of 5ms.
 595        * This is valid upto 250ms
 596        * Hence converting the enum value to actual value by multiplying it to 5
 597        */
 598       statProhTmr = statProhTmrCfg * 5;
 599    }
 600    else
 601    {
 602       switch(statProhTmrCfg)
 603       {
 604          case T_StatusProhibit_ms300:
 605             statProhTmr = 300;
 606             break;
 607          case T_StatusProhibit_ms350:
 608             statProhTmr = 350;
 609             break;
 610          case T_StatusProhibit_ms400:
 611             statProhTmr = 400;
 612             break;
 613          case T_StatusProhibit_ms450:
 614             statProhTmr = 450;
 615             break;
 616          case T_StatusProhibit_ms500:
 617             statProhTmr = 500;
 618             break;
 619          case T_StatusProhibit_ms800:
 620             statProhTmr = 800;
 621             break;
 622          case T_StatusProhibit_ms1000:
 623             statProhTmr = 1000;
 624             break;
 625          case T_StatusProhibit_ms1200:
 626             statProhTmr = 1200;
 627             break;
 628          case T_StatusProhibit_ms1600:
 629             statProhTmr = 1600;
 630             break;
 631          case T_StatusProhibit_ms2000:
 632             statProhTmr = 2000;
 633             break;
 634          case T_StatusProhibit_ms2400:
 635             statProhTmr = 2400;
 636             break;
 637          default:
 638             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 639             statProhTmr = -1;
 640             break;
 641       }
 642    }
 643    return statProhTmr;
 644 }
 645
 646 /*******************************************************************
 647 *
 648 * @brief Adding F1AP pdu to reserved pdu list
 649 *
 650 * @details
 651 *
 652 *    Function : addToReservedF1apPduList
 653 *
 654 *    Functionality: Adding F1AP pdu to reserved pdu list.
 655 *     These pdu are awaiting aknowledgment from CU
 656 *
 657 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 658 *
 659 * @return ROK - success
 660 *         RFAILED - failure
 661 *
 662 * ****************************************************************/
 663
 664 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 665 {
 666    CmLList         *node = NULLP;
 667    ReservedF1apPduInfo *pduInfo = NULLP;
 668    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 669    if(pduInfo)
 670    {
 671       DU_ALLOC(node, sizeof(CmLList));
 672       if(node)
 673       {
 674          pduInfo->transId = transId;
 675          pduInfo->f1apMsg = (void*) f1apPdu;
 676
 677          node->node = (PTR)pduInfo;
 678          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 679       }
 680    }
 681 }
 682
 683 /*******************************************************************
 684 *
 685 * @brief searching for F1AP pdu from ReservedF1apPduList
 686 *
 687 * @details
 688 *
 689 *    Function : searchFromReservedF1apPduList
 690 *
 691 *    Functionality: searching for F1AP pdu information
 692 *
 693 * @params[in] uint8_t transId
 694 *
 695 * @return pointer to F1AP_PDU_t
 696 *
 697 * ****************************************************************/
 698
 699 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 700 {
 701    CmLList         *node;
 702    ReservedF1apPduInfo *f1apPdu;
 703    if(duCb.reservedF1apPduList.count)
 704    {
 705       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 706       while(node)
 707       {
 708          f1apPdu = (ReservedF1apPduInfo*)node->node;
 709          if(f1apPdu->transId == transId)
 710          {
 711             return node;
 712          }
 713          node = node->next;
 714       }
 715    }
 716    return NULL;
 717 }
 718
 719 /*******************************************************************
 720 *
 721 * @brief deleting F1AP pdu information from ReservedF1apPduList
 722 *
 723 * @details
 724 *
 725 *    Function : deleteFromReservedF1apPduList
 726 *
 727 *    Functionality: deleting pdu information from ReservedF1apPduList
 728 *
 729 * @params[in] CmLList *node
 730 *
 731 * @return void
 732 *
 733 * ****************************************************************/
 734
 735 void deleteFromReservedF1apPduList(CmLList *node)
 736 {
 737    ReservedF1apPduInfo *f1apPdu;
 738
 739    if(node != NULL)
 740    {
 741       f1apPdu = (ReservedF1apPduInfo *)node->node;
 742       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 743       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 744       DU_FREE(node, sizeof(CmLList));
 745       node = NULL;
 746    }
 747 }
 748
 749 /*******************************************************************
 750  *
 751  * @brief Builds Uplink Info for NR
 752  *
 753  * @details
 754  *
 755  *    Function : BuildULNRInfo
 756  *
 757  *    Functionality: Building NR Uplink Info
 758  *
 759  * @params[in] NRFreqInfo_t *ulnrfreq
 760  * @return ROK     - success
 761  *         RFAILED - failure
 762  *
 763  * ****************************************************************/
 764 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 765 {
 766    uint8_t idx=0;
 767    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 768                        fdd.ulNrFreqInfo.nrArfcn;
 769    ulnrfreq->freqBandListNr.list.count = 1;
 770    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 771    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 772    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 773    {
 774       return RFAILED;
 775    }
 776    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 777    {
 778       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 779       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 780       {
 781          return RFAILED;
 782       }
 783    }
 784    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 785                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 786                                                                  freqBand[0].nrFreqBand;
 787    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 788    return ROK;
 789 }
 790 /*******************************************************************
 791  *
 792  * @brief Builds Downlink NR Info
 793  *
 794  * @details
 795  *
 796  *    Function : BuildDLNRInfo
 797  *
 798  *    Functionality: Building Downlink NR Info
 799  *
 800  * @params[in] NRFreqInfo_t *dlnrfreq
 801  * @return ROK     - success
 802  *         RFAILED - failure
 803  *
 804  * ****************************************************************/
 805 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 806 {
 807    uint8_t idx=0;
 808    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 809                        fdd.dlNrFreqInfo.nrArfcn;
 810    dlnrfreq->freqBandListNr.list.count = 1;
 811    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 812    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 813    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 814    {
 815       return RFAILED;
 816    }
 817    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 818    {
 819       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 820       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 821       {
 822          return RFAILED;
 823       }
 824    }
 825    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 826                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 827                                                                  freqBand[0].nrFreqBand;
 828    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 829
 830    return ROK;
 831 }
 832
 833 /*******************************************************************
 834  *
 835  * @brief Builds NRCell ID
 836  *
 837  * @details
 838  *
 839  *    Function : BuildNrCellId
 840  *
 841  *    Functionality: Building the NR Cell ID
 842  *
 843  * @params[in] BIT_STRING_t *nrcell
 844  * @return ROK     - success
 845  *         RFAILED - failure
 846  *
 847  * ****************************************************************/
 848
 849 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 850 {
 851    memset(nrcell->buf, 0, nrcell->size);
 852    nrcell->buf[4]   = duCfgParam.sib1Params.cellIdentity;
 853    nrcell->bits_unused = 4;
 854    return ROK;
 855 }
 856
 857 /*******************************************************************
 858  *
 859  * @brief Builds Nrcgi
 860  *
 861  * @details
 862  *
 863  *    Function : BuildNrcgi
 864  *
 865  *    Functionality: Building the PLMN ID and NR Cell id
 866  *
 867  * @params[in] NRCGI_t *nrcgi
 868  * @return ROK     - success
 869  *         RFAILED - failure
 870  *
 871  * ****************************************************************/
 872 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 873 {
 874    uint8_t ret;
 875    uint8_t byteSize = 5;
 876    /* Allocate Buffer Memory */
 877    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 878    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 879    if(nrcgi->pLMN_Identity.buf == NULLP)
 880    {
 881       return RFAILED;
 882    }
 883    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 884          nrcgi->pLMN_Identity.buf); // Building PLMN function
 885    if(ret != ROK)
 886    {
 887       return RFAILED;
 888    }
 889    /*nrCellIdentity*/
 890    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 891    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 892    if(nrcgi->nRCellIdentity.buf == NULLP)
 893    {
 894       return RFAILED;
 895    }
 896    BuildNrCellId(&nrcgi->nRCellIdentity);
 897
 898    return ROK;
 899 }
 900 /*******************************************************************
 901  *
 902  * @brief Builds FiveGStac
 903  *
 904  * @details
 905  *
 906  *    Function : BuildFiveGSTac
 907  *
 908  *    Functionality: Building the FiveGSTac
 909  *
 910  * @params[in] OCTET_STRING_t *fivegsTac
 911  * @return ROK     - success
 912  *         RFAILED - failure
 913  *
 914  * ****************************************************************/
 915 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 916 {
 917    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 918    if(servcell->fiveGS_TAC == NULLP)
 919    {
 920       return RFAILED;
 921    }
 922    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 923    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 924          sizeof(servcell->fiveGS_TAC->size));
 925    if(servcell->fiveGS_TAC->buf == NULLP)
 926    {
 927       return RFAILED;
 928    }
 929    servcell->fiveGS_TAC->buf[0] = 0;
 930    servcell->fiveGS_TAC->buf[1] = 0;
 931    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 932    return ROK;
 933 }
 934
 935 /*******************************************************************
 936  *
 937  * @brief fill nr frequency information
 938  *
 939  * @details
 940  *
 941  *    Function : fillNrTddInfo
 942  *
 943  *    Functionality: fill nr frequency information
 944  *
 945  * @params[in] NRFreqInfo_t freqInfo
 946  * @return ROK     - success
 947  *         RFAILED - failure
 948  *
 949  * ****************************************************************/
 950 uint8_t fillNrTddInfo(TDD_Info_t *tddInfo)
 951 {
 952    uint8_t elementCnt = 1, freqBandListIdx = 0, supportedBandIdx = 0;
 953    NRFreqInfo_t *freqInfo = NULLP;
 954
 955    if(tddInfo == NULLP)
 956    {
 957       DU_LOG("\nERROR  --> DU APP : Null pointer received at fillNrTddInfo");
 958       return RFAILED;
 959    }
 960
 961    freqInfo = &tddInfo->nRFreqInfo;
 962    freqInfo->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn;
 963
 964    freqInfo->freqBandListNr.list.count = elementCnt;
 965    freqInfo->freqBandListNr.list.size = freqInfo->freqBandListNr.list.count  * sizeof(FreqBandNrItem_t *);
 966    DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
 967    if(!freqInfo->freqBandListNr.list.array)
 968    {
 969       DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 970       return RFAILED;
 971    }
 972
 973    for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
 974    {
 975       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
 976       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
 977       {
 978          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 979          return RFAILED;
 980       }
 981
 982       freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
 983       f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
 984       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
 985       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
 986       supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
 987
 988       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
 989             freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
 990       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
 991       {
 992          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 993          return RFAILED;
 994       }
 995
 996       for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
 997       {
 998          DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
 999                sizeof(SupportedSULFreqBandItem_t));
1000          if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
1001          {
1002             DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
1003             return RFAILED;
1004          }
1005
1006          freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx]->freqBandIndicatorNr =\
1007          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.freqBand[0].sulBand[0];
1008       }
1009    }
1010
1011    tddInfo->transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs;
1012    tddInfo->transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb;
1013
1014    return ROK;
1015 }
1016
1017 /*******************************************************************
1018  *
1019  * @brief Builds NR Mode
1020  *
1021  * @details
1022  *
1023  *    Function : BuildNrMode
1024  *
1025  *    Functionality: Building the NR Mode
1026  *
1027  * @params[in] NR_Mode_Info_t *fdd
1028  * @return ROK     - success
1029  *         RFAILED - failure
1030  *
1031  * ****************************************************************/
1032 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
1033 {
1034    uint8_t BuildDLNRInforet=0;
1035    uint8_t BuildULNRInforet=0;
1036
1037 #ifdef NR_TDD
1038    mode->present = NR_Mode_Info_PR_tDD;
1039 #else
1040    mode->present = NR_Mode_Info_PR_fDD;
1041 #endif
1042
1043    if(mode->present == NR_Mode_Info_PR_fDD)
1044    {
1045       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
1046       if(mode->choice.fDD == NULLP)
1047       {
1048          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
1049          return RFAILED;
1050       }
1051       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
1052       if(BuildULNRInforet != ROK)
1053       {
1054          DU_LOG("\nERROR  --> Failed to build UlNrFreqInfo");
1055          return RFAILED;
1056       }
1057       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
1058       if(BuildDLNRInforet != ROK)
1059       {
1060          DU_LOG("\nERROR  --> Failed to build DlNrFreqInfo");
1061          return RFAILED;
1062       }
1063       mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
1064                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
1065                                                           f1Mode.mode.fdd.ulTxBw.nrScs;
1066       mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
1067                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
1068                                                           f1Mode.mode.fdd.ulTxBw.nrb;
1069       mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
1070                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
1071                                                           f1Mode.mode.fdd.dlTxBw.nrScs;
1072       mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
1073                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
1074                                                           f1Mode.mode.fdd.dlTxBw.nrb;
1075    }
1076    else if(mode->present == NR_Mode_Info_PR_tDD)
1077    {
1078       DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
1079       if(mode->choice.tDD == NULLP)
1080       {
1081          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
1082          return RFAILED;
1083       }
1084
1085       if(fillNrTddInfo(mode->choice.tDD) != ROK)
1086       {
1087          DU_LOG("\nERROR  --> Failed to fill Nr TDD information");
1088          return RFAILED;
1089       }
1090
1091    }
1092
1093    return ROK;
1094 }
1095 /*******************************************************************
1096  *
1097  * @brief Builds IE Extensions for Served PLMNs
1098  *
1099  * @details
1100  *
1101  *    Function : BuildExtensions
1102  *
1103  *    Functionality: Building the IE Extensions
1104  *
1105  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
1106  * @return ROK     - success
1107  *         RFAILED - failure
1108  *
1109  * ****************************************************************/
1110 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
1111 {
1112    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
1113    uint8_t elementCnt=0, extensionCnt=0;
1114
1115    extensionCnt=IE_EXTENSION_LIST_COUNT;
1116    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
1117    if((*ieExtend) == NULLP)
1118    {
1119       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1120       return RFAILED;
1121    }
1122    (*ieExtend)->list.count = extensionCnt;
1123    (*ieExtend)->list.size = \
1124                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
1125    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
1126    if((*ieExtend)->list.array == NULLP)
1127    {
1128       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1129       return RFAILED;
1130    }
1131    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
1132    {
1133       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
1134             sizeof(ServedPLMNs_ItemExtIEs_t));
1135       if((*ieExtend)->list.array[plmnidx] == NULLP)
1136       {
1137          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1138          return RFAILED;
1139       }
1140    }
1141
1142    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1143    idx = 0;
1144    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
1145    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
1146    (*ieExtend)->list.array[idx]->extensionValue.present = \
1147    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1148    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1149       list.count = elementCnt;
1150    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1151       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1152       list.count * sizeof(SliceSupportItem_t *);
1153
1154    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1155          list.array, elementCnt * sizeof(SliceSupportItem_t *));
1156    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1157          list.array == NULLP)
1158    {
1159       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1160       return RFAILED;
1161    }
1162
1163    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
1164    {
1165       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1166             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
1167       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1168             list.array[sliceLstIdx] == NULLP)
1169       {
1170          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1171          return RFAILED;
1172       }
1173       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1174          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1175       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1176             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1177             extensionValue.choice.SliceSupportList.\
1178             list.array[sliceLstIdx]->sNSSAI.sST.size);
1179       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1180             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1181       {
1182          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1183          return RFAILED;
1184       }
1185       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1186          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
1187          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1188
1189       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1190             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1191       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1192             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1193       {
1194          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1195          return RFAILED;
1196       }
1197       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1198          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1199       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1200             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
1201             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1202       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1203             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1204       {
1205          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1206          return RFAILED;
1207       }
1208       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1209       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
1210       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
1211       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1212    }
1213    return ROK;
1214 }
1215 /*******************************************************************
1216  *
1217  * @brief Builds Served PLMN
1218  *
1219  * @details
1220  *
1221  *    Function : BuildServedPlmn
1222  *
1223  *    Functionality: Building the Served PLMN
1224  *
1225  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1226  * @return ROK     - success
1227  *         RFAILED - failure
1228  *
1229  * ****************************************************************/
1230 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1231 {
1232    uint8_t  plmnidx;
1233    uint8_t  servPlmnCnt=1;
1234    uint8_t buildPlmnIdret=0;
1235    uint8_t BuildExtensionsret=0;
1236    srvplmn->list.count = servPlmnCnt;
1237    srvplmn->list.size = \
1238                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1239    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1240    if(srvplmn->list.array == NULLP)
1241    {
1242       return RFAILED;
1243    }
1244    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1245    {
1246       DU_ALLOC(srvplmn->list.array[plmnidx],\
1247             sizeof(ServedPLMNs_Item_t));
1248       if(srvplmn->list.array[plmnidx] == NULLP)
1249       {
1250          return RFAILED;
1251       }
1252    }
1253    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1254    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1255    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1256          srvplmn->list.array[0]->pLMN_Identity.buf);
1257    if(buildPlmnIdret!= ROK)
1258    {
1259       return RFAILED;
1260    }
1261    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1262    if(BuildExtensionsret!= ROK)
1263    {
1264       return RFAILED;
1265    }
1266    return ROK;
1267 }
1268 /*******************************************************************
1269  *
1270  * @brief Builds Served Cell List
1271  *
1272  * @details
1273  *
1274  *    Function : BuildServedCellList
1275  *
1276  *    Functionality: Building Served Cell List
1277  *
1278  * @params[in] PLMNID plmn
1279  * @return ROK     - success
1280  *         RFAILED - failure
1281  *
1282  * ****************************************************************/
1283
1284 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1285 {
1286    uint8_t  BuildNrcgiret=0;
1287    uint8_t  BuildFiveGSTacret=0;
1288    uint8_t  BuildServedPlmnret=0;
1289    uint8_t  BuildNrModeret=0;
1290    uint8_t  idx;
1291    uint8_t  plmnidx;
1292    uint8_t  plmnCnt=1;
1293    GNB_DU_Served_Cells_Item_t *srvCellItem;
1294    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1295    duServedCell->list.count = plmnCnt;
1296
1297    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1298    if(duServedCell->list.array == NULLP)
1299    {
1300       return RFAILED;
1301    }
1302    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1303    {
1304       DU_ALLOC(duServedCell->list.array[plmnidx],\
1305             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1306       if(duServedCell->list.array[plmnidx] == NULLP)
1307       {
1308          return RFAILED;
1309       }
1310    }
1311    idx = 0;
1312    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1313    duServedCell->list.array[idx]->criticality = Criticality_reject;
1314    duServedCell->list.array[idx]->value.present = \
1315                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1316    srvCellItem = \
1317                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1318    /*nRCGI*/
1319    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1320    if(BuildNrcgiret != ROK)
1321    {
1322       return RFAILED;
1323    }
1324    /*nRPCI*/
1325    srvCellItem->served_Cell_Information.nRPCI = \
1326                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1327
1328    /*fiveGS_TAC*/
1329    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1330    if(BuildFiveGSTacret != ROK)
1331    {
1332       return RFAILED;
1333    }
1334    /*Served PLMNs*/
1335    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1336    if(BuildServedPlmnret !=ROK)
1337    {
1338       return RFAILED;
1339    }
1340    /*nR Mode Info with FDD*/
1341    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1342    if(BuildNrModeret != ROK)
1343    {
1344       return RFAILED;
1345    }
1346    /*Measurement timing Config*/
1347    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1348       size = sizeof(uint8_t);
1349    DU_ALLOC(srvCellItem->served_Cell_Information.\
1350          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1351    if(srvCellItem->served_Cell_Information.\
1352          measurementTimingConfiguration.buf == NULLP)
1353    {
1354       return RFAILED;
1355    }
1356    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1357                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1358
1359    /* GNB DU System Information */
1360    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1361          sizeof(GNB_DU_System_Information_t));
1362    if(!srvCellItem->gNB_DU_System_Information)
1363    {
1364       return RFAILED;
1365    }
1366    /* MIB */
1367    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1368    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1369          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1370    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1371    {
1372       return RFAILED;
1373    }
1374    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1375                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1376
1377    /* SIB1 */
1378    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1379                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1380
1381    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1382          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1383    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1384    {
1385       return RFAILED;
1386    }
1387    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1388    {
1389       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1390                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1391    }
1392    return ROK;
1393 }
1394 /*******************************************************************
1395  *
1396  * @brief Builds RRC Version
1397  *
1398  * @details
1399  *
1400  *    Function : BuildRrcVer
1401  *
1402  *    Functionality: Building RRC Version
1403  *
1404  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1405  * @return ROK     - success
1406  *         RFAILED - failure
1407  *
1408  * ****************************************************************/
1409 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1410 {
1411    uint8_t rrcExt;
1412    uint8_t rrcLatest;
1413    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1414    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1415    if(rrcVer->latest_RRC_Version.buf == NULLP)
1416    {
1417       return RFAILED;
1418    }
1419    rrcVer->latest_RRC_Version.buf[0] = 0;
1420    rrcVer->latest_RRC_Version.bits_unused = 5;
1421    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1422    if(rrcVer->iE_Extensions == NULLP)
1423    {
1424       return RFAILED;
1425    }
1426    rrcVer->iE_Extensions->list.count = 1;
1427    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1428    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1429    if(rrcVer->iE_Extensions->list.array == NULLP)
1430    {
1431       return RFAILED;
1432    }
1433    rrcExt = 0;
1434    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1435          sizeof(RRC_Version_ExtIEs_t));
1436    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1437    {
1438       return RFAILED;
1439    }
1440    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1441                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1442    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1443    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1444                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1445    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1446       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1447    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1448          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1449          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1450    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1451          .Latest_RRC_Version_Enhanced.buf == NULLP)
1452    {
1453       return RFAILED;
1454    }
1455    rrcLatest = 0;
1456    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1457       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1458    rrcLatest++;
1459    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1460       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1461    rrcLatest++;
1462    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1463       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1464    return ROK;
1465 }
1466 /*******************************************************************
1467  *
1468  * @brief Sends F1 msg over SCTP
1469  *
1470  * @details
1471  *
1472  *    Function : sendF1APMsg
1473  *
1474  *    Functionality: Sends F1 msg over SCTP
1475  *
1476  * @params[in] Region region
1477  *             Pool pool
1478  * @return ROK     - success
1479  *         RFAILED - failure
1480  *
1481  * ****************************************************************/
1482 uint8_t sendF1APMsg()
1483 {
1484    Buffer *mBuf = NULLP;
1485
1486    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1487    {
1488       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1489       {
1490             ODU_PRINT_MSG(mBuf, 0,0);
1491
1492             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1493             {
1494                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1495                ODU_PUT_MSG_BUF(mBuf);
1496                return RFAILED;
1497             }
1498       }
1499       else
1500       {
1501          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1502          ODU_PUT_MSG_BUF(mBuf);
1503          return RFAILED;
1504       }
1505       ODU_PUT_MSG_BUF(mBuf);
1506    }
1507    else
1508    {
1509       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1510       return RFAILED;
1511    }
1512    return ROK;
1513 } /* sendF1APMsg */
1514
1515 /*******************************************************************
1516  *
1517  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1518  *
1519  * @details
1520  *
1521  *    Function :  FreeRrcVer
1522  *
1523  *    Functionality: deallocating the memory of function BuildRrcVer
1524  *
1525  * @params[in] RRC_Version_t *rrcVer
1526  *
1527  * @return void
1528  *
1529  *****************************************************************/
1530 void FreeRrcVer(RRC_Version_t *rrcVer)
1531 {
1532    if(rrcVer->latest_RRC_Version.buf != NULLP)
1533    {
1534       if(rrcVer->iE_Extensions != NULLP)
1535       {
1536          if(rrcVer->iE_Extensions->list.array != NULLP)
1537          {
1538             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1539             {
1540                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1541                      != NULLP)
1542                {
1543                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1544                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1545                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1546                }
1547                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1548             }
1549             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1550          }
1551          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1552       }
1553       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1554    }
1555 }
1556
1557 /*******************************************************************
1558  *
1559  * @brief Deallocating memory of TDD NrFreqInfo
1560  *
1561  * @details
1562  *
1563  *    Function : freeTddNrFreqInfo
1564  *
1565  *    Functionality: freeTddNrFreqInfo
1566  *
1567  * @params[in]  F1AP_PDU_t *f1apDuCfg
1568  *
1569  * @return ROK     - void
1570  *
1571  * ****************************************************************/
1572 void freeTddNrFreqInfo(NRFreqInfo_t *freqInfo)
1573 {
1574    uint8_t freqBandListIdx = 0, supportedBandIdx = 0;
1575
1576    if(freqInfo->freqBandListNr.list.array)
1577    {
1578       for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
1579       {
1580          if(freqInfo->freqBandListNr.list.array[freqBandListIdx])
1581          {
1582             if(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
1583             {
1584                for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
1585                {
1586                   DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1587                         sizeof(SupportedSULFreqBandItem_t));
1588                }
1589                DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
1590                      freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
1591
1592             }
1593             DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
1594          }
1595       }
1596       DU_FREE(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
1597    }
1598 }
1599
1600 /*******************************************************************
1601  *
1602  * @brief Deallocating memory allocated for Nr fdd frequencey mode
1603  *
1604  * @details
1605  *
1606  *    Function : freeFddNrFreqInfo
1607  *
1608  *    Functionality:Free memory allocated for Nr fdd frequencey mode
1609  *
1610  * @params[in]
1611  *
1612  * @return ROK     - void
1613  *
1614  * ****************************************************************/
1615 void freeFddNrFreqInfo(FDD_Info_t *fDD)
1616 {
1617    uint8_t arrIdx =0;
1618
1619    if(fDD != NULLP)
1620    {
1621       if(fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1622       {
1623          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1624                array[arrIdx], sizeof(FreqBandNrItem_t));
1625          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1626                fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1627       }
1628
1629       if(fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1630       {
1631          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.\
1632                array[arrIdx], sizeof(FreqBandNrItem_t));
1633          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1634                fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1635       }
1636       DU_FREE(fDD,sizeof(FDD_Info_t));
1637    }
1638 }
1639
1640 /*******************************************************************
1641  *
1642  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1643  *
1644  * @details
1645  *
1646  *    Function :  FreeServedCellList
1647  *
1648  *    Functionality:  deallocating the memory of function BuildServedCellList
1649
1650  *
1651  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1652  *
1653  * @return void
1654  *
1655  * ****************************************************************/
1656 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1657 {
1658    uint8_t   plmnCnt=MAX_PLMN;
1659    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1660    uint8_t  plmnIdx=0, sliceIdx=0;
1661    GNB_DU_Served_Cells_Item_t *srvCellItem;
1662    ServedPLMNs_Item_t  *servedPlmnItem;
1663    SliceSupportItem_t  *sliceSupportItem;
1664
1665    if(duServedCell->list.array!=NULLP)
1666    {
1667       if(duServedCell->list.array[0]!=NULLP)
1668       {
1669          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1670
1671          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1672                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1673          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1674                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1675
1676          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1677          {
1678             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1679                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1680             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1681          }
1682
1683          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1684          {
1685             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1686             {
1687                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1688                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1689
1690                if(servedPlmnItem->iE_Extensions != NULLP)
1691                {
1692                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1693                   {
1694                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1695                      {
1696                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1697                               SliceSupportList.list.array != NULLP)
1698                         {
1699                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1700                                  extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1701                            {
1702                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1703                                     SliceSupportList.list.array[sliceIdx] != NULLP)
1704                               {
1705                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1706                                                     extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1707
1708                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1709
1710                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1711                                  {
1712                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1713                                           sliceSupportItem->sNSSAI.sD->size);
1714                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1715                                  }
1716
1717                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1718                                        choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1719                               }
1720                            }
1721                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1722                                  SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1723                                  extensionValue.choice.SliceSupportList.list.size);
1724                         }
1725                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1726                               sizeof(ServedPLMNs_ItemExtIEs_t));
1727                      }
1728                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1729                            extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1730                   }
1731                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1732                }
1733                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1734                      sizeof(ServedPLMNs_Item_t));
1735             }
1736             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1737                   sizeof(ServedPLMNs_Item_t *));
1738          }
1739
1740          if(srvCellItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1741          {
1742             freeFddNrFreqInfo(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1743          }
1744          else
1745          {
1746             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD != NULLP)
1747             {
1748                freeTddNrFreqInfo(&srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1749                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1750             }
1751          }
1752
1753          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1754                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1755
1756          if(srvCellItem->gNB_DU_System_Information != NULLP)
1757          {
1758             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1759             {
1760                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1761                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1762             }
1763
1764             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1765             {
1766                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1767                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1768             }
1769
1770             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1771          }
1772
1773          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1774       }
1775       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1776    }
1777 }
1778
1779 /*******************************************************************
1780  *
1781  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1782  *
1783  * @details
1784  *
1785  *    Function :  FreeF1SetupReq
1786  *
1787  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1788  *
1789  * @params[in] F1AP_PDU_t *f1apMsg
1790  *
1791  * @return void
1792  *
1793  * ****************************************************************/
1794 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1795 {
1796    uint8_t ieIdx, ieIdx2;
1797    F1SetupRequest_t *f1SetupReq=NULLP;
1798
1799    if(f1apMsg != NULLP)
1800    {
1801       if(f1apMsg->choice.initiatingMessage != NULLP)
1802       {
1803          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1804          if(f1SetupReq->protocolIEs.list.array != NULLP)
1805          {
1806             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1807             {
1808                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1809                {
1810                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1811                   {
1812                      case ProtocolIE_ID_id_TransactionID:
1813                         break;
1814                      case ProtocolIE_ID_id_gNB_DU_ID:
1815                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1816                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1817                         break;
1818                      case ProtocolIE_ID_id_gNB_DU_Name:
1819                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1820                               strlen((char *)duCfgParam.duName));
1821                         break;
1822                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1823                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1824                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1825                         break;
1826                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1827                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1828                         break;
1829                      default:
1830                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1831                         break;
1832                   }
1833                }
1834             }
1835             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1836             {
1837                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1838             }
1839             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1840                   f1SetupReq->protocolIEs.list.size);
1841          }
1842          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1843       }
1844       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1845    }
1846 }
1847 /*******************************************************************
1848  *
1849  * @brief Builds and Send the F1SetupRequest
1850  *
1851  * @details
1852  *
1853  *    Function : BuildAndSendF1SetupReq
1854  *
1855  * Functionality:Fills the F1SetupRequest
1856  *
1857  * @return ROK     - success
1858  *         RFAILED - failure
1859  *
1860  ******************************************************************/
1861 uint8_t BuildAndSendF1SetupReq()
1862 {
1863    uint8_t   ret, ieIdx, elementCnt;
1864    F1AP_PDU_t                 *f1apMsg = NULLP;
1865    F1SetupRequest_t           *f1SetupReq=NULLP;
1866    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1867    RRC_Version_t              *rrcVer=NULLP;
1868    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1869    ret= RFAILED;
1870
1871    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1872    do
1873    {
1874       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1875       if(f1apMsg == NULLP)
1876       {
1877          break;
1878       }
1879       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1880       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1881       if(f1apMsg->choice.initiatingMessage == NULLP)
1882       {
1883          break;
1884       }
1885       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1886       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1887       f1apMsg->choice.initiatingMessage->value.present = \
1888                                                          InitiatingMessage__value_PR_F1SetupRequest;
1889
1890       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1891
1892       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1893
1894       f1SetupReq->protocolIEs.list.count = elementCnt;
1895       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1896
1897       /* Initialize the F1Setup members */
1898       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1899       if(f1SetupReq->protocolIEs.list.array == NULLP)
1900       {
1901          break;
1902       }
1903       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1904       {
1905          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1906                sizeof(F1SetupRequestIEs_t));
1907          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1908          {
1909             break;
1910          }
1911       }
1912
1913       ieIdx = 0;
1914       /*TransactionID*/
1915       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1916       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1917       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1918                                                                F1SetupRequestIEs__value_PR_TransactionID;
1919       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1920                                                                              TRANS_ID;
1921
1922       /*DU ID*/
1923       ieIdx++;
1924       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1925       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1926       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1927                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1928       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1929                                                                              sizeof(uint8_t);
1930
1931       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1932             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1933       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1934             NULLP)
1935       {
1936          break;
1937       }
1938
1939       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1940          duCfgParam.duId;
1941
1942       /*DU Name*/
1943       if(duCfgParam.duName != NULL)
1944       {
1945          ieIdx++;
1946          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1947          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1948          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1949          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1950             strlen((char *)duCfgParam.duName);
1951          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1952                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1953          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1954                buf == NULLP)
1955          {
1956             break;
1957          }
1958          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1959                choice.GNB_DU_Name.buf,
1960                (char*)&duCfgParam.duName);
1961
1962       }
1963
1964       /*Served Cell list */
1965       ieIdx++;
1966       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1967                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1968       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1969       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1970                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1971       duServedCell = &f1SetupReq->protocolIEs.list.\
1972                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1973       if(BuildServedCellList(duServedCell))
1974       {
1975          break;
1976       }
1977       /*RRC Version*/
1978       ieIdx++;
1979       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1980                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1981       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1982       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1983                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1984       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1985       if(BuildRrcVer(rrcVer))
1986       {
1987          break;
1988       }
1989       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1990
1991       /* Encode the F1SetupRequest type as APER */
1992       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1993       encBufSize = 0;
1994       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1995             encBuf);
1996
1997       /* Encode results */
1998       if(encRetVal.encoded == ENCODE_FAIL)
1999       {
2000          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
2001                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2002          break;
2003       }
2004       else
2005       {
2006          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
2007          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
2008          {
2009             printf("%x",encBuf[ieIdx]);
2010          }
2011       }
2012
2013       /* Sending msg */
2014       if(sendF1APMsg() != ROK)
2015       {
2016          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
2017          break;
2018       }
2019
2020       ret=ROK;
2021       break;
2022    }while(true);
2023
2024    FreeF1SetupReq(f1apMsg);
2025
2026    return ret;
2027 }/* End of BuildAndSendF1SetupReq */
2028
2029 /*******************************************************************
2030  *
2031  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
2032  *
2033  * @details
2034  *
2035  *    Function : freeCellsToModifyItem
2036  *
2037  *    Functionality: Deallocating memory of variables allocated in
2038  *                    BuildAndSendDUConfigUpdate function
2039  *
2040  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
2041  *
2042  * @return ROK     - void
2043  *
2044  * ****************************************************************/
2045
2046 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
2047 {
2048    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
2049    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
2050    SliceSupportItem_t *sliceSupportItem = NULLP;
2051
2052    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
2053    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
2054
2055    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2056            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
2057    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2058          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
2059
2060    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
2061    {
2062       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
2063       {
2064          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
2065
2066          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
2067
2068          if(servedPlmnItem->iE_Extensions != NULLP)
2069          {
2070             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
2071             {
2072                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
2073                {
2074                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
2075                         list.array != NULLP)
2076                   {
2077                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
2078                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
2079                      {
2080                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
2081                               list.array[sliceLstIdx] != NULLP)
2082                         {
2083
2084                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
2085                                               SliceSupportList.list.array[sliceLstIdx];
2086
2087                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
2088                            if(sliceSupportItem->sNSSAI.sD != NULLP)
2089                            {
2090                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
2091                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
2092                            }
2093                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
2094                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
2095                         }
2096                      }
2097                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
2098                            choice.SliceSupportList.list.array,\
2099                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
2100                            extensionValue.choice.SliceSupportList.list.size);
2101                   }
2102                }
2103                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
2104                {
2105                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
2106                }
2107                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
2108             }
2109             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2110          }
2111       }
2112       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
2113       {
2114          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
2115       }
2116       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2117          modifyItem->served_Cell_Information.servedPLMNs.list.size);
2118    }
2119
2120    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
2121    {
2122       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
2123    }
2124    else
2125    {
2126       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
2127       {
2128          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
2129          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2130       }
2131    }
2132    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
2133       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
2134 }
2135
2136 /*******************************************************************
2137  *
2138  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
2139  *
2140  * @details
2141  *
2142  *    Function : FreeDUConfigUpdate
2143  *
2144  *    Functionality: Deallocating memory of variables allocated in
2145  *                    BuildAndSendDUConfigUpdate function
2146  *
2147  * @params[in]  F1AP_PDU_t *f1apDuCfg
2148  *
2149  * @return ROK     - void
2150  *
2151  * ****************************************************************/
2152 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
2153 {
2154    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
2155    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2156    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
2157    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
2158    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
2159    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
2160
2161    if(f1apDuCfg != NULLP)
2162    {
2163       if(f1apDuCfg->choice.initiatingMessage != NULLP)
2164       {
2165          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
2166                        value.choice.GNBDUConfigurationUpdate;
2167          if(duCfgUpdate->protocolIEs.list.array != NULLP)
2168          {
2169             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
2170             {
2171                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
2172                {
2173                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
2174                   {
2175                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
2176                         {
2177                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
2178                                            value.choice.Served_Cells_To_Modify_List;
2179                            if(cellsToModify->list.array != NULLP)
2180                            {
2181                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
2182                               {
2183                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
2184                                  {
2185                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
2186                                           Served_Cells_To_Modify_Item);
2187                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
2188                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
2189                                  }
2190                               }
2191                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
2192                            }
2193                            break;
2194                         }
2195                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
2196                         {
2197                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
2198                                            value.choice.Served_Cells_To_Delete_List;
2199                            if(cellsToDelete->list.array != NULLP)
2200                            {
2201                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
2202                               {
2203                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
2204                                  {
2205                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
2206                                           cellsToDelete->list.array[cellDeleteIdx]);
2207                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2208                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
2209                                           deleteItem->oldNRCGI.pLMN_Identity.size);
2210                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2211                                           deleteItem->oldNRCGI.nRCellIdentity.size);
2212                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
2213                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
2214                                  }
2215                               }
2216                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
2217                            }
2218
2219                            break;
2220                         }
2221                      case ProtocolIE_ID_id_gNB_DU_ID:
2222                         {
2223                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2224                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2225                            break;
2226                         }
2227                   }
2228                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2229                         sizeof(GNBDUConfigurationUpdateIEs_t));
2230                }
2231             }
2232             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2233          }
2234          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2235       }
2236       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2237    }
2238 }
2239
2240 /*******************************************************************
2241  *
2242  * @brief Fills Served Plmns required in ServCellInfo IE
2243  *
2244  * @details
2245  *
2246  *    Function : fillServedPlmns
2247  *
2248  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2249  *
2250  * @params[in] Pointer to ServedPLMNs_List_t *
2251  *
2252  * @return ROK     - success
2253  *         RFAILED - failure
2254  *
2255  *****************************************************************/
2256
2257 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2258 {
2259    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2260
2261    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2262    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2263          array[arrayIdx]->pLMN_Identity.size);
2264    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2265    {
2266       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2267       return RFAILED;
2268    }
2269    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2270          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2271    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2272    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2273    {
2274       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2275       return RFAILED;
2276    }
2277
2278    ieListCnt=1;
2279    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2280    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2281    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2282          iE_Extensions->list.size);
2283    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2284    {
2285       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2286       return RFAILED;
2287    }
2288    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2289    {
2290       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2291             sizeof(ServedPLMNs_ItemExtIEs_t));
2292       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2293       {
2294          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2295          return RFAILED;
2296       }
2297    }
2298
2299    ieIdx = 0;
2300    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
2301    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2302    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2303    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2304    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2305    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2306       list.count = elementCnt;
2307    servedPlmn->list.array[arrayIdx]->\
2308       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2309       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2310    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2311          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2312          list.array,servedPlmn->list.array[arrayIdx]->\
2313          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2314    if(servedPlmn->list.array[arrayIdx]->\
2315          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2316          list.array == NULLP)
2317    {
2318       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2319       return RFAILED;
2320    }
2321
2322    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2323    {
2324       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2325       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2326       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2327       if(servedPlmn->list.array[arrayIdx]->\
2328       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2329       list.array[sliceLstIdx] == NULLP)
2330       {
2331          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2332          return RFAILED;
2333       }
2334
2335       servedPlmn->list.array[arrayIdx]->\
2336       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2337       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2338       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2339       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2340       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2341       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2342       sNSSAI.sST.size);
2343
2344       if(servedPlmn->list.array[arrayIdx]->\
2345       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2346       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2347       {
2348          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2349          return RFAILED;
2350       }
2351       servedPlmn->list.array[arrayIdx]->\
2352       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2353       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2354       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2355
2356       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2357       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2358       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2359       if(servedPlmn->list.array[arrayIdx]->\
2360       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2361       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2362       {
2363          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2364          return RFAILED;
2365       }
2366       servedPlmn->list.array[arrayIdx]->\
2367       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2368       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2369       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2370       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2371       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2372       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2373       list.array[sliceLstIdx]->sNSSAI.sD->size);
2374       if(servedPlmn->list.array[arrayIdx]->\
2375       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2376       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2377       {
2378          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2379          return RFAILED;
2380       }
2381       memcpy(servedPlmn->list.array[arrayIdx]->\
2382       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2383       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2384       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2385       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2386       list.array[sliceLstIdx]->sNSSAI.sD->size);
2387    }
2388    return ROK;
2389 }
2390
2391 /*******************************************************************
2392  *
2393  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2394  *
2395  * @details
2396  *
2397  *    Function : fillNrFddInfo
2398  *
2399  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2400  *
2401  * @params[in] FDD_Info_t *fDD
2402  *
2403  * @return ROK     - success
2404  *         RFAILED - failure
2405  *
2406  *****************************************************************/
2407
2408 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
2409 {
2410    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2411       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2412    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2413    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2414    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
2415          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2416    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2417    {
2418       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2419       return RFAILED;
2420    }
2421
2422    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2423       sizeof(FreqBandNrItem_t));
2424    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2425    {
2426       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2427       return RFAILED;
2428    }
2429
2430    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2431       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2432       freqBand[0].nrFreqBand;
2433    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2434    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2435       dlNrFreqInfo.nrArfcn;
2436    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2437    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2438    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2439    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2440    {
2441       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2442       return RFAILED;
2443    }
2444
2445    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
2446    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2447    {
2448       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2449       return RFAILED;
2450    }
2451
2452    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2453       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2454       freqBand[0].nrFreqBand;
2455    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2456
2457    /*Transmission Bandwidth*/
2458    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2459       f1Mode.mode.fdd.ulTxBw.nrScs;
2460    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2461       f1Mode.mode.fdd.ulTxBw.nrb;
2462    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2463       f1Mode.mode.fdd.dlTxBw.nrScs;
2464    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2465       f1Mode.mode.fdd.dlTxBw.nrb;
2466
2467    return ROK;
2468 }
2469
2470 /*******************************************************************
2471  *
2472  * @brief Fills ServCellInfo IE
2473  *
2474  * @details
2475  *
2476  *    Function : fillServedCellInfo
2477  *
2478  *    Functionality: Fills ServCellInfo
2479  *
2480  * @params[in] Pointer to Served_Cell_Information_t *
2481  *
2482  * @return ROK     - success
2483  *         RFAILED - failure
2484  *
2485  *****************************************************************/
2486
2487 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2488 {
2489    uint8_t ieIdx, ieListCnt;
2490
2491    /*nRCGI*/
2492    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2493    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2494          srvCellInfo->nRCGI.pLMN_Identity.size);
2495    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2496    {
2497       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2498       return RFAILED;
2499    }
2500    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2501          srvCellInfo->nRCGI.pLMN_Identity.buf);
2502    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2503    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2504          srvCellInfo->nRCGI.nRCellIdentity.size);
2505    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2506    {
2507       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2508       return RFAILED;
2509    }
2510
2511    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2512    /*nRPCI*/
2513    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2514
2515    /*servedPLMNs*/
2516    ieListCnt = 1;
2517    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2518    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2519    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2520    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2521    {
2522       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2523       return RFAILED;
2524    }
2525    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2526    {
2527       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2528       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2529       {
2530          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2531          return RFAILED;
2532       }
2533    }
2534    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2535    {
2536       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2537       return RFAILED;
2538    }
2539
2540 #ifndef NR_TDD
2541    /*nR Mode Info with FDD*/
2542    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2543    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2544    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2545    {
2546       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2547       return RFAILED;
2548    }
2549    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2550    {
2551        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2552       return RFAILED;
2553    }
2554 #else
2555    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2556    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2557    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2558    {
2559       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2560       return RFAILED;
2561    }
2562    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2563    {
2564       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2565       return RFAILED;
2566    }
2567 #endif
2568
2569    /*Measurement timing Config*/
2570    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2571    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2572          buf,srvCellInfo->measurementTimingConfiguration.size);
2573    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2574    {
2575       return RFAILED;
2576    }
2577    srvCellInfo->measurementTimingConfiguration.\
2578          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2579
2580    return ROK;
2581 }
2582
2583 /*******************************************************************
2584  *
2585  * @brief Fills ServCellToModItem IE
2586  *
2587  * @details
2588  *
2589  *    Function : fillServCellToModItem
2590  *
2591  *    Functionality: Fills ServCellToModItem IE
2592  *
2593  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2594  *
2595  * @return ROK     - success
2596  *         RFAILED - failure
2597  *
2598  *****************************************************************/
2599
2600 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2601 {
2602    /*pLMN_Identity*/
2603    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2604    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2605    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2606    {
2607       return RFAILED;
2608    }
2609    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2610          modifyItem->oldNRCGI.pLMN_Identity.buf);
2611
2612    /*nRCellIdentity*/
2613    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2614    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2615          modifyItem->oldNRCGI.nRCellIdentity.size);
2616    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2617    {
2618       return RFAILED;
2619    }
2620    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2621
2622    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2623       return RFAILED;
2624    else
2625       return ROK;
2626 }
2627
2628 /*******************************************************************
2629  *
2630  * @brief Builds ServCellToModList
2631  *
2632  * @details
2633  *
2634  *    Function : buildServCellToModList
2635  *
2636  *    Functionality: Builds the serv cell to Mod List
2637  *
2638  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2639  *
2640  * @return ROK     - success
2641  *         RFAILED - failure
2642  *
2643  *****************************************************************/
2644
2645 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2646 {
2647    uint8_t ieListCnt, ieIdx;
2648    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2649
2650    ieListCnt = 1;
2651    cellsToModify->list.count = ieListCnt;
2652    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2653    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2654    if(cellsToModify->list.array == NULLP)
2655    {
2656       return RFAILED;
2657    }
2658    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2659    {
2660       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2661       if(cellsToModify->list.array[ieIdx] == NULLP)
2662       {
2663          return RFAILED;
2664       }
2665    }
2666    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2667    cellsToModify->list.array[0]->criticality = Criticality_reject;
2668    cellsToModify->list.array[0]->value.present =\
2669       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2670    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2671
2672    if(fillServCellToModItem(modifyItem))
2673       return RFAILED;
2674    else
2675       return ROK;
2676 }
2677 /*******************************************************************
2678  *
2679  * @brief filling the DeleteItemList
2680  *
2681  * @details
2682  *
2683  *    Function : fillCellToDeleteItem
2684  *
2685  *    Functionality: Filling the DeleteItemIe
2686  *
2687  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2688  *
2689  * @return ROK     - success
2690  *         RFAILED - failure
2691  *
2692  *****************************************************************/
2693 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2694 {
2695    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2696
2697    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2698    deleteItemIe->criticality = Criticality_reject;
2699    deleteItemIe->value.present =\
2700    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2701    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2702
2703    /*pLMN_Identity*/
2704    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2705    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2706    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2707    {
2708       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2709       return RFAILED;
2710    }
2711    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2712          deleteItem->oldNRCGI.pLMN_Identity.buf);
2713
2714    /*nRCellIdentity*/
2715    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2716    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2717          deleteItem->oldNRCGI.nRCellIdentity.size);
2718    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2719    {
2720       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2721       return RFAILED;
2722    }
2723    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2724    return ROK;
2725 }
2726 /*******************************************************************
2727  *
2728  * @brief Builds ServCellToDeleteList
2729  *
2730  * @details
2731  *
2732  *    Function : buildServCellToDeleteList
2733  *
2734  *    Functionality: Builds the serv cell to delete List
2735  *
2736  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2737  *
2738  * @return ROK     - success
2739  *         RFAILED - failure
2740  *
2741  *****************************************************************/
2742
2743 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2744 {
2745    uint8_t ieListCnt, arrIdx;
2746
2747    ieListCnt = 1;
2748    cellsToDelete->list.count = ieListCnt;
2749    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2750
2751    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2752    if(cellsToDelete->list.array == NULLP)
2753    {
2754       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2755       return RFAILED;
2756    }
2757
2758    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2759    {
2760       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2761       if(cellsToDelete->list.array[arrIdx] == NULLP)
2762       {
2763          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2764          return RFAILED;
2765       }
2766    }
2767
2768    arrIdx=0;
2769    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2770    {
2771       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2772       return RFAILED;
2773    }
2774    return ROK;
2775 }
2776
2777 /*******************************************************************
2778  *
2779  * @brief Builds and sends the DUConfigUpdate
2780  *
2781  * @details
2782  *
2783  *    Function : BuildAndSendDUConfigUpdate
2784  *
2785  *    Functionality: Constructs the DU Update message and sends
2786  *                   it to the CU through SCTP.
2787  *
2788  * @params[in] void **buf,Buffer to which encoded pattern is written into
2789  * @params[in] int *size,size of buffer
2790  *
2791  * @return ROK     - success
2792  *         RFAILED - failure
2793  *
2794  * ****************************************************************/
2795 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2796 {
2797    uint8_t ret =0, ieIdx=0, elementCnt=0;
2798    bool memAlloctionFailure = false;
2799    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2800    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2801    asn_enc_rval_t encRetVal;     /* Encoder return value */
2802
2803    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2804    ret= RFAILED;
2805
2806    while(true)
2807    {
2808       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2809       /* Allocate the memory for F1DuCfg */
2810       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2811       if(f1apDuCfg == NULLP)
2812       {
2813          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2814          break;
2815       }
2816
2817       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2818       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2819       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2820       {
2821          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2822          break;
2823       }
2824
2825       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2826                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2827       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2828       f1apDuCfg->choice.initiatingMessage->value.present = \
2829                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2830       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2831                     choice.GNBDUConfigurationUpdate;
2832       elementCnt = 3;
2833       duCfgUpdate->protocolIEs.list.count = elementCnt;
2834       duCfgUpdate->protocolIEs.list.size = \
2835                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2836
2837       /* Initialize the F1Setup members */
2838       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2839       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2840       {
2841          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2842          break;
2843       }
2844       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2845       {
2846          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2847          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2848          {
2849             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2850             memAlloctionFailure = true;
2851             break;
2852          }
2853       }
2854
2855       if(memAlloctionFailure == true)
2856       {
2857          break;
2858       }
2859       /*TransactionID*/
2860       ieIdx = 0;
2861       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2862       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2863       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2864       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2865       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2866
2867       ieIdx++;
2868       if(servCellAction == SERV_CELL_TO_MODIFY)
2869       {
2870          /*Served Cell to Modify */
2871          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2872          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2873          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2874          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2875          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2876          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2877                   Served_Cells_To_Modify_List))
2878          {
2879             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2880             break;
2881          }
2882       }
2883       else
2884       {
2885          /*Served Cell to Delete */
2886          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2887          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2888          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2889          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2890          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2891          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2892          Served_Cells_To_Delete_List)!=ROK)
2893          {
2894             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2895             break;
2896          }
2897
2898       }
2899       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2900       /*GNB DU ID */
2901       ieIdx++;
2902       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2903       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2904       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2905       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2906       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2907       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2908             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2909       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2910       {
2911          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2912          break;
2913       }
2914       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2915
2916       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2917
2918       /* Encode the DU Config Update type as APER */
2919       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2920       encBufSize = 0;
2921       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2922
2923       /* Checking encode results */
2924       if(encRetVal.encoded == ENCODE_FAIL)
2925       {
2926          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2927                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2928          break;
2929       }
2930       else
2931       {
2932          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2933          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2934          {
2935             printf("%x",encBuf[ieIdx]);
2936          }
2937       }
2938       /* Sending msg */
2939       if(sendF1APMsg() != ROK)
2940       {
2941          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2942          break;
2943       }
2944
2945       ret = ROK;
2946       break;
2947    }
2948
2949    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2950    return ret;
2951 }
2952
2953
2954 /*******************************************************************
2955  *
2956  * @brief free the ULRRCMessageTransfer
2957  *
2958  * @details
2959  *
2960  *    Function : FreeULRRCMessageTransfer
2961  *
2962  *    Functionality: Deallocating the memory of variable allocated in
2963  *                      FreeULRRCMessageTransfer
2964  *
2965  * @params[in]
2966  *
2967  * @return ROK     - void
2968  *
2969  ******************************************************************/
2970 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2971 {
2972    uint8_t idx1;
2973    ULRRCMessageTransfer_t  *ulRRCMsg;
2974
2975    if(f1apMsg != NULLP)
2976    {
2977       if(f1apMsg->choice.initiatingMessage != NULLP)
2978       {
2979          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2980          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2981          {
2982             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2983             {
2984                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2985                {
2986                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2987                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2988                   {
2989                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2990                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2991                   }
2992                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2993                }
2994             }
2995             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2996          }
2997          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2998       }
2999       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
3000    }
3001 }
3002 /*******************************************************************
3003  *
3004  * @brief Builds and sends the ULRRCMessageTransfer
3005  *
3006  * @details
3007  *
3008  *    Function : BuildAndSendULRRCMessageTransfer
3009  *
3010  *    Functionality: Constructs the UL RRC Message Transfer and sends
3011  *                   it to the CU through SCTP.
3012  *
3013  * @params[in]
3014  *
3015  * @return ROK     - success
3016  *         RFAILED - failure
3017  *
3018  * ****************************************************************/
3019 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
3020       uint16_t msgLen, uint8_t *rrcMsg)
3021 {
3022    uint8_t   elementCnt =0;
3023    uint8_t   idx1 =0;
3024    uint8_t   idx =0;
3025    F1AP_PDU_t                   *f1apMsg = NULLP;
3026    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
3027    asn_enc_rval_t               encRetVal;        /* Encoder return value */
3028    uint8_t ret =RFAILED;
3029
3030    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
3031
3032    while(true)
3033    {
3034       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
3035
3036       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
3037       if(f1apMsg == NULLP)
3038       {
3039          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
3040          break;
3041       }
3042       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
3043       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3044       if(f1apMsg->choice.initiatingMessage == NULLP)
3045       {
3046          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
3047          break;
3048       }
3049       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
3050       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
3051       f1apMsg->choice.initiatingMessage->value.present = \
3052                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
3053       ulRRCMsg =
3054          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
3055       elementCnt = 4;
3056       ulRRCMsg->protocolIEs.list.count = elementCnt;
3057       ulRRCMsg->protocolIEs.list.size = \
3058                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
3059
3060       /* Initialize the F1Setup members */
3061       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
3062       if(ulRRCMsg->protocolIEs.list.array == NULLP)
3063       {
3064          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
3065          break;
3066       }
3067       for(idx=0; idx<elementCnt; idx++)
3068       {
3069          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
3070          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
3071          {
3072             break;
3073          }
3074       }
3075
3076       idx1 = 0;
3077
3078       /*GNB CU UE F1AP ID*/
3079       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
3080       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
3081       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
3082                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
3083       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
3084
3085       /*GNB DU UE F1AP ID*/
3086       idx1++;
3087       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
3088       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
3089       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
3090                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
3091       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
3092
3093       /*SRBID*/
3094       idx1++;
3095       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
3096       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
3097       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
3098                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
3099       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
3100
3101       /*RRCContainer*/
3102       idx1++;
3103       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
3104       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
3105       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
3106                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
3107       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
3108       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
3109             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
3110       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
3111       {
3112          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
3113          break;
3114       }
3115       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
3116       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
3117             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
3118
3119       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
3120
3121       /* Encode the F1SetupRequest type as APER */
3122       memset(encBuf, 0, ENC_BUF_MAX_LEN);
3123       encBufSize = 0;
3124       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
3125             encBuf);
3126       /* Encode results */
3127       if(encRetVal.encoded == ENCODE_FAIL)
3128       {
3129          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
3130                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3131          break;
3132       }
3133       else
3134       {
3135          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
3136          for(int i=0; i< encBufSize; i++)
3137          {
3138             printf("%x",encBuf[i]);
3139          }
3140       }
3141
3142       /* Sending  msg  */
3143       if(sendF1APMsg()  !=      ROK)
3144       {
3145          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
3146          break;
3147       }
3148       ret = ROK;
3149       break;
3150    }
3151    FreeULRRCMessageTransfer(f1apMsg);
3152
3153    return ret;
3154 }/* End of BuildAndSendULRRCMessageTransfer*/
3155
3156 /*******************************************************************
3157  *
3158  * @brief Builds tag config
3159  *
3160  * @details
3161  *
3162  *    Function : BuildTagConfig
3163  *
3164  *    Functionality: Builds tag config in MacCellGroupConfig
3165  *
3166  * @params[in] TAG_Config *tag_Config
3167  *
3168  * @return ROK     - success
3169  *         RFAILED - failure
3170  *
3171  * ****************************************************************/
3172 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
3173 {
3174    struct TAG_Config__tag_ToAddModList *tagList;
3175    uint8_t                     idx, elementCnt;
3176
3177    tagConfig->tag_ToReleaseList = NULLP;
3178    tagConfig->tag_ToAddModList = NULLP;
3179    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
3180    if(!tagConfig->tag_ToAddModList)
3181    {
3182       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3183       return RFAILED;
3184    }
3185
3186    elementCnt = 1; //ODU_VALUE_ONE;
3187    tagList = tagConfig->tag_ToAddModList;
3188    tagList->list.count = elementCnt;
3189    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
3190
3191    tagList->list.array = NULLP;
3192    DU_ALLOC(tagList->list.array, tagList->list.size);
3193    if(!tagList->list.array)
3194    {
3195       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3196       return RFAILED;
3197    }
3198
3199    for(idx=0; idx<tagList->list.count; idx++)
3200    {
3201       tagList->list.array[idx] = NULLP;
3202       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
3203       if(!tagList->list.array[idx])
3204       {
3205          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3206          return RFAILED;
3207       }
3208    }
3209
3210    idx = 0;
3211    tagList->list.array[idx]->tag_Id = TAG_ID;
3212    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
3213
3214    return ROK;
3215 }
3216
3217 /*******************************************************************
3218  *
3219  * @brief Builds PHR Config
3220  *
3221  * @details
3222  *
3223  *    Function : BuildPhrConfig
3224  *
3225  *    Functionality: Builds phrConfig in MacCellGroupConfig
3226  *
3227  * @params[in] PHR Config *
3228  *
3229  * @return ROK     - success
3230  *         RFAILED - failure
3231  *
3232  * ****************************************************************/
3233 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3234 {
3235
3236    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3237    phrConfig->choice.setup = NULLP;
3238    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3239    if(!phrConfig->choice.setup)
3240    {
3241       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3242       return RFAILED;
3243    }
3244
3245    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3246    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3247    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3248    phrConfig->choice.setup->multiplePHR              = false;
3249    phrConfig->choice.setup->dummy                    = false;
3250    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3251    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3252
3253    return ROK;
3254 }
3255
3256 /*******************************************************************
3257  *
3258  * @brief Builds BSR Config
3259  *
3260  * @details
3261  *
3262  *    Function : BuildBsrConfig
3263  *
3264  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3265  *
3266  * @params[in] BSR_Config *bsrConfig
3267  *
3268  * @return ROK     - success
3269  *         RFAILED - failure
3270  *
3271  * ****************************************************************/
3272 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3273 {
3274    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3275    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3276    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3277
3278    return ROK;
3279 }
3280
3281 /*******************************************************************
3282  *
3283  * @brief Builds scheduling request config
3284  *
3285  * @details
3286  *
3287  *    Function : BuildSchedulingReqConfig
3288  *
3289  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3290  *
3291  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3292  *
3293  * @return ROK     - success
3294  *         RFAILED - failure
3295  *
3296  * ****************************************************************/
3297 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3298 {
3299    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3300    uint8_t                     idx, elementCnt;
3301
3302    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3303    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3304          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3305    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3306    {
3307       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3308       return RFAILED;
3309    }
3310
3311    elementCnt = 1; //ODU_VALUE_ONE;
3312    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3313    schReqList->list.count = elementCnt;
3314    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3315
3316    schReqList->list.array = NULLP;
3317    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3318    if(!schReqList->list.array)
3319    {
3320       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3321       return RFAILED;
3322    }
3323
3324    for(idx=0;idx<schReqList->list.count; idx++)
3325    {
3326       schReqList->list.array[idx] = NULLP;
3327       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3328       if(!schReqList->list.array[idx])
3329       {
3330          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3331          return RFAILED;
3332       }
3333    }
3334
3335    idx = 0;
3336    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3337
3338    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3339    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3340    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3341    {
3342       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3343       return RFAILED;
3344    }
3345    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3346    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3347    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3348
3349    return ROK;
3350 }
3351
3352 /*******************************************************************
3353  *
3354  * @brief Builds RLC Config
3355  *
3356  * @details
3357  *
3358  *    Function : BuildRlcConfig
3359  *
3360  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3361  *
3362  * @params[in] RLC_Config *rlcConfig
3363  *
3364  * @return ROK     - success
3365  *         RFAILED - failure
3366  *
3367  * ****************************************************************/
3368 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3369 {
3370
3371    rlcConfig->present = RLC_Config_PR_am;
3372
3373    rlcConfig->choice.am = NULLP;
3374    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3375    if(!rlcConfig->choice.am)
3376    {
3377       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3378       return RFAILED;
3379    }
3380
3381    /* UL */
3382    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3383    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3384    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3385    {
3386       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3387       return RFAILED;
3388    }
3389    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3390    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3391    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3392    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3393    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3394
3395    /* DL */
3396    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3397    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3398    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3399    {
3400       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3401       return RFAILED;
3402    }
3403    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3404    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3405    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3406
3407    return ROK;
3408 }
3409
3410 /*******************************************************************
3411  *
3412  * @brief Builds MAC LC Config
3413  *
3414  * @details
3415  *
3416  *    Function : BuildMacLCConfig
3417  *
3418  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3419  *
3420  * @params[in] struct LogicalChannelConfig macLcConfig
3421  *
3422  * @return ROK     - success
3423  *         RFAILED - failure
3424  *
3425  * ****************************************************************/
3426 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3427 {
3428
3429    macLcConfig->ul_SpecificParameters = NULLP;
3430    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3431    if(!macLcConfig->ul_SpecificParameters)
3432    {
3433       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3434       return RFAILED;
3435    }
3436
3437    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3438    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3439    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3440    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3441    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3442    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3443    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3444
3445    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3446    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3447    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3448    {
3449       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3450       return RFAILED;
3451    }
3452    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3453
3454    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3455    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3456    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3457    {
3458       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3459       return RFAILED;
3460    }
3461    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3462
3463    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3464    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3465    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3466
3467    return ROK;
3468 }
3469
3470 /*******************************************************************
3471  *
3472  * @brief Builds RLC Bearer to Add/Mod list
3473  *
3474  * @details
3475  *
3476  *    Function :BuildRlcBearerToAddModList
3477  *
3478  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3479  *
3480  * @params[in] rlc_BearerToAddModList
3481  *
3482  * @return ROK     - success
3483  *         RFAILED - failure
3484  *
3485  * ****************************************************************/
3486 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3487 {
3488    uint8_t                     idx, elementCnt;
3489
3490    elementCnt = 1;
3491    rlcBearerList->list.count = elementCnt;
3492    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3493
3494    rlcBearerList->list.array = NULLP;
3495    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3496    if(!rlcBearerList->list.array)
3497    {
3498       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3499       return RFAILED;
3500    }
3501
3502    for(idx=0; idx<rlcBearerList->list.count; idx++)
3503    {
3504       rlcBearerList->list.array[idx] = NULLP;
3505       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3506       if(!rlcBearerList->list.array[idx])
3507       {
3508          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3509          return RFAILED;
3510       }
3511    }
3512
3513    idx = 0;
3514    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3515
3516    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3517       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3518    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3519    {
3520       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3521       return RFAILED;
3522    }
3523
3524    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3525       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3526    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3527       SRB1_LCID;
3528
3529    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3530    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3531    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3532    if(!rlcBearerList->list.array[idx]->rlc_Config)
3533    {
3534       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3535       return RFAILED;
3536    }
3537
3538    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3539    {
3540       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3541       return RFAILED;
3542    }
3543
3544    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3545    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3546       sizeof(struct LogicalChannelConfig));
3547    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3548    {
3549       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3550       return RFAILED;
3551    }
3552
3553    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3554    {
3555       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3556       return RFAILED;
3557    }
3558
3559    return ROK;
3560 }
3561
3562 /*******************************************************************
3563  *
3564  * @brief Build Control resource set to add/modify list
3565  *
3566  * @details
3567  *
3568  *    Function : BuildControlRSetToAddModList
3569  *
3570  *    Functionality: Build Control resource set to add/modify list
3571  *
3572  * @params[in]
3573  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3574  *
3575  * @return ROK     - success
3576  *         RFAILED - failure
3577  *
3578  * ****************************************************************/
3579    uint8_t BuildControlRSetToAddModList
3580 (
3581  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3582  )
3583 {
3584    uint8_t idx;
3585    uint8_t elementCnt;
3586    uint8_t numBytes, bitsUnused;
3587    struct ControlResourceSet *controlRSet;
3588    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3589    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3590
3591
3592    elementCnt = 1;
3593    controlRSetList->list.count = elementCnt;
3594    controlRSetList->list.size = \
3595                                 elementCnt * sizeof(struct ControlResourceSet *);
3596
3597    controlRSetList->list.array = NULLP;
3598    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3599    if(!controlRSetList->list.array)
3600    {
3601       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3602       return RFAILED;
3603    }
3604
3605    for(idx = 0; idx < elementCnt; idx++)
3606    {
3607       controlRSetList->list.array[idx] = NULLP;
3608       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3609       if(!controlRSetList->list.array[idx])
3610       {
3611          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3612          return RFAILED;
3613       }
3614    }
3615
3616    idx=0;
3617    controlRSet = controlRSetList->list.array[idx];
3618
3619    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3620
3621    /* size 6 bytes
3622     * 3 LSBs unsued
3623     * Bit string stored ff0000000000
3624     */
3625    numBytes = 6;
3626    bitsUnused = 3;
3627    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3628
3629    controlRSet->frequencyDomainResources.buf = NULLP;
3630    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3631          controlRSet->frequencyDomainResources.size);
3632    if(!controlRSet->frequencyDomainResources.buf)
3633    {
3634       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3635       return RFAILED;
3636    }
3637
3638    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3639    coreset0EndPrb = CORESET0_END_PRB;
3640    coreset1StartPrb = coreset0EndPrb + 6;
3641    coreset1NumPrb = CORESET1_NUM_PRB;
3642    /* calculate the PRBs */
3643    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3644    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3645    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3646
3647    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3648    controlRSet->cce_REG_MappingType.present = \
3649                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3650
3651    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3652    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3653    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3654    controlRSet->tci_PresentInDCI = NULLP;
3655 #if 0
3656    uint8_t tciStateIdx;
3657
3658    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3659          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3660    if(!controlRset->tci_StatesPDCCH_ToAddList)
3661    {
3662       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3663       return RFAILED;
3664    }
3665
3666    elementCnt = 1;
3667    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3668    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3669    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3670          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3671       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3672       {
3673          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3674          return RFAILED;
3675       }
3676
3677    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3678    {
3679       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3680       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3681       {
3682          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3683          return RFAILED;
3684       }
3685    }
3686
3687    tciStateIdx = 0;
3688    /* TODO */
3689    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3690
3691    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3692    if(!controlRset->tci_PresentInDCI)
3693    {
3694       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3695       return RFAILED;
3696    }
3697    /* TODO */
3698    *(controlRset->tci_PresentInDCI);
3699 #endif
3700
3701    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3702    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3703    if(!controlRSet->pdcch_DMRS_ScramblingID)
3704    {
3705       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3706       return RFAILED;
3707    }
3708    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3709
3710    return ROK;
3711 } /* End BuildControlRSetToAddModList */
3712
3713 /*******************************************************************
3714  *
3715  * @brief Build search space to add/modify list
3716  *
3717  * @details
3718  *
3719  *    Function : BuildSearchSpcToAddModList
3720  *
3721  *    Functionality: Build search space to add/modify list
3722  *
3723  * @params[in]
3724  * @return ROK     - success
3725  *         RFAILED - failure
3726  *
3727  * ****************************************************************/
3728    uint8_t BuildSearchSpcToAddModList
3729 (
3730  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3731  )
3732 {
3733    uint8_t idx;
3734    uint8_t numBytes;
3735    uint8_t byteIdx;
3736    uint8_t bitsUnused;
3737    uint8_t elementCnt;
3738    struct SearchSpace *searchSpc;
3739
3740    elementCnt = 1;
3741    searchSpcList->list.count = elementCnt;
3742    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3743
3744    searchSpcList->list.array = NULLP;
3745    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3746    if(!searchSpcList->list.array)
3747    {
3748       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3749       return RFAILED;
3750    }
3751
3752    for(idx = 0; idx < elementCnt; idx++)
3753    {
3754       searchSpcList->list.array[idx] = NULLP;
3755       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3756       if(!searchSpcList->list.array[idx])
3757       {
3758          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3759          return RFAILED;
3760       }
3761    }
3762
3763    idx = 0;
3764    searchSpc = searchSpcList->list.array[idx];
3765
3766    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3767
3768    searchSpc->controlResourceSetId = NULLP;
3769    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3770    if(!searchSpc->controlResourceSetId)
3771    {
3772       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3773       return RFAILED;
3774    }
3775    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3776
3777    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3778    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3779          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3780    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3781    {
3782       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3783       return RFAILED;
3784    }
3785    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3786                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3787
3788    searchSpc->duration = NULLP;
3789    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3790    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3791    if(!searchSpc->monitoringSymbolsWithinSlot)
3792    {
3793       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3794       return RFAILED;
3795    }
3796
3797    /* Values taken from reference logs :
3798     * size 2 bytes
3799     * 2 LSBs unsued
3800     * Bit string stores 8000
3801     */
3802    numBytes = 2;
3803    bitsUnused = 2;
3804
3805    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3806    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3807    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3808          searchSpc->monitoringSymbolsWithinSlot->size);
3809    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3810    {
3811       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3812       return RFAILED;
3813    }
3814
3815    byteIdx = 0;
3816    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3817                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3818    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3819    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3820
3821    searchSpc->nrofCandidates = NULLP;
3822    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3823    if(!searchSpc->nrofCandidates)
3824    {
3825       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3826       return RFAILED;
3827    }
3828
3829    searchSpc->nrofCandidates->aggregationLevel1 = \
3830                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3831    searchSpc->nrofCandidates->aggregationLevel2 = \
3832                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3833    searchSpc->nrofCandidates->aggregationLevel4 = \
3834                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3835    searchSpc->nrofCandidates->aggregationLevel8 = \
3836                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3837    searchSpc->nrofCandidates->aggregationLevel16 = \
3838                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3839
3840    searchSpc->searchSpaceType = NULLP;
3841    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3842    if(!searchSpc->searchSpaceType)
3843    {
3844       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3845       return RFAILED;
3846    }
3847
3848    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3849
3850    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3851    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3852          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3853    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3854    {
3855       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3856       return RFAILED;
3857    }
3858    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3859                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3860
3861    return ROK;
3862 }/* End BuildSearchSpcToAddModList */
3863
3864 /*******************************************************************
3865  *
3866  * @brief Builds BWP DL dedicated PDCCH config
3867  *
3868  * @details
3869  *
3870  *    Function : BuildBWPDlDedPdcchCfg
3871  *
3872  *    Functionality: Builds BWP DL dedicated PDCCH config
3873  *
3874  * @params[in] struct PDCCH_Config *pdcchCfg
3875  *
3876  * @return ROK     - success
3877  *         RFAILED - failure
3878  *
3879  * ****************************************************************/
3880 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3881 {
3882    pdcchCfg->controlResourceSetToAddModList = NULLP;
3883    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3884          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3885    if(!pdcchCfg->controlResourceSetToAddModList)
3886    {
3887       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3888       return RFAILED;
3889    }
3890
3891    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3892    {
3893       return RFAILED;
3894    }
3895
3896    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3897
3898    pdcchCfg->searchSpacesToAddModList = NULLP;
3899    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3900          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3901    if(!pdcchCfg->searchSpacesToAddModList)
3902    {
3903       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3904       return RFAILED;
3905    }
3906
3907    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3908    {
3909       return RFAILED;
3910    }
3911
3912    pdcchCfg->searchSpacesToReleaseList = NULLP;
3913    pdcchCfg->downlinkPreemption = NULLP;
3914    pdcchCfg->tpc_PUSCH = NULLP;
3915    pdcchCfg->tpc_PUCCH = NULLP;
3916    pdcchCfg->tpc_SRS = NULLP;
3917
3918    return ROK;
3919 }
3920
3921 /*******************************************************************
3922  *
3923  * @brief Builds DMRS DL PDSCH Mapping type A
3924  *
3925  * @details
3926  *
3927  *    Function : BuildDMRSDLPdschMapTypeA
3928  *
3929  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3930  *
3931  * @params[in]
3932  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3933  * @return ROK     - success
3934  *         RFAILED - failure
3935  *
3936  * ****************************************************************/
3937    uint8_t BuildDMRSDLPdschMapTypeA
3938 (
3939  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3940  )
3941 {
3942    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3943    dmrsDlCfg->choice.setup = NULLP;
3944    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3945    if(!dmrsDlCfg->choice.setup)
3946    {
3947       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3948       return RFAILED;
3949    }
3950
3951    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3952    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3953    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3954    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3955    {
3956       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3957       return RFAILED;
3958    }
3959    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3960
3961    dmrsDlCfg->choice.setup->maxLength = NULLP;
3962    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3963    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3964    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3965
3966    return ROK;
3967 }
3968
3969 /*******************************************************************
3970  *
3971  * @brief Builds TCI states to add/modify list
3972  *
3973  * @details
3974  *
3975  *    Function : BuildTCIStatesToAddModList
3976  *
3977  *    Functionality:Builds TCI states to add/modify list
3978  *
3979  * @params[in]
3980  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3981  *
3982  * @return ROK     - success
3983  *         RFAILED - failure
3984  *
3985  * ****************************************************************/
3986 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3987 {
3988    return ROK;
3989 }
3990
3991 /*******************************************************************
3992  *
3993  * @brief Builds PDSCH time domain allocation list
3994  *
3995  * @details
3996  *
3997  *    Function : BuildPdschTimeDomAllocList
3998  *
3999  *    Functionality: Builds PDSCH time domain allocation list
4000  *
4001  * @params[in]
4002  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4003  *
4004  * @return ROK     - success
4005  *         RFAILED - failure
4006  *
4007  * ****************************************************************/
4008    uint8_t BuildPdschTimeDomAllocList
4009 (
4010  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4011  )
4012 {
4013    uint8_t idx;
4014    uint8_t elementCnt;
4015    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
4016
4017    timeDomAllocList->present = \
4018                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
4019
4020    timeDomAllocList->choice.setup = NULLP;
4021    DU_ALLOC(timeDomAllocList->choice.setup, \
4022          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4023    if(!timeDomAllocList->choice.setup)
4024    {
4025       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4026       return RFAILED;
4027    }
4028
4029    elementCnt = 2;
4030    timeDomAllocList->choice.setup->list.count = elementCnt;
4031    timeDomAllocList->choice.setup->list.size = \
4032                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
4033
4034    timeDomAllocList->choice.setup->list.array = NULLP;
4035    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4036          timeDomAllocList->choice.setup->list.size);
4037    if(!timeDomAllocList->choice.setup->list.array)
4038    {
4039       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4040       return RFAILED;
4041    }
4042
4043    for(idx = 0; idx < elementCnt; idx++)
4044    {
4045       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4046       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
4047             sizeof(struct PDSCH_TimeDomainResourceAllocation));
4048       if(!timeDomAllocList->choice.setup->list.array[idx])
4049       {
4050          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4051          return RFAILED;
4052       }
4053    }
4054
4055    idx = 0;
4056    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4057    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4058    if(!timeDomAlloc->k0)
4059    {
4060       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4061       return RFAILED;
4062    }
4063    *(timeDomAlloc->k0) = 0;
4064    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4065    timeDomAlloc->startSymbolAndLength = \
4066                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4067
4068    idx++;
4069    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4070    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4071    if(!timeDomAlloc->k0)
4072    {
4073       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4074       return RFAILED;
4075    }
4076    *(timeDomAlloc->k0) = 1;
4077    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4078    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4079
4080    return ROK;
4081 }
4082
4083 /*******************************************************************
4084  *
4085  * @brief Builds PDSCH PRB Bundling type
4086  *
4087  * @details
4088  *
4089  *    Function : BuildPdschPrbBundlingType
4090  *
4091  *    Functionality: Builds PDSCH PRB Bundling type
4092  *
4093  * @params[in]
4094  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4095  *
4096  * @return ROK     - success
4097  *         RFAILED - failure
4098  *
4099  * ****************************************************************/
4100    uint8_t BuildPdschPrbBundlingType
4101 (
4102  struct PDSCH_Config__prb_BundlingType *prbBndlType
4103  )
4104 {
4105    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4106
4107    prbBndlType->choice.staticBundling = NULLP;
4108    DU_ALLOC(prbBndlType->choice.staticBundling, \
4109          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4110    if(!prbBndlType->choice.staticBundling)
4111    {
4112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4113       return RFAILED;
4114    }
4115    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4116
4117    return ROK;
4118 }
4119
4120 /*******************************************************************
4121  *
4122  * @brief Builds BWP DL dedicated PDSCH config
4123  *
4124  * @details
4125  *
4126  *    Function : BuildBWPDlDedPdschCfg
4127  *
4128  *    Functionality: Builds BWP DL dedicated PDSCH config
4129  *
4130  * @params[in] struct PDSCH_Config *pdschCfg
4131  *
4132  * @return ROK     - success
4133  *         RFAILED - failure
4134  *
4135  * ****************************************************************/
4136 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
4137 {
4138    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4139
4140    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4141    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4142          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4143    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4144    {
4145       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4146       return RFAILED;
4147    }
4148
4149    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4150    {
4151       return RFAILED;
4152    }
4153
4154    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4155    pdschCfg->tci_StatesToAddModList = NULLP;
4156    pdschCfg->tci_StatesToReleaseList = NULLP;
4157    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4158 #if 0
4159    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4160    if(!pdschCfg->tci_StatesToAddModList)
4161    {
4162       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4163       return RFAILED;
4164    }
4165    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4166    {
4167       return RFAILED;
4168    }
4169 #endif
4170
4171    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4172
4173    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4174    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
4175          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4176    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4177    {
4178       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4179       return RFAILED;
4180    }
4181
4182    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4183    {
4184       return RFAILED;
4185    }
4186
4187    pdschCfg->pdsch_AggregationFactor = NULLP;
4188    pdschCfg->rateMatchPatternToAddModList = NULLP;
4189    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4190    pdschCfg->rateMatchPatternGroup1 = NULLP;
4191    pdschCfg->rateMatchPatternGroup2 = NULLP;
4192    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4193    pdschCfg->mcs_Table = NULLP;
4194
4195    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4196    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4197    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4198    {
4199       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4200       return RFAILED;
4201    }
4202    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4203
4204    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
4205    {
4206       return RFAILED;
4207    }
4208
4209    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4210    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4211    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4212    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4213    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4214    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4215    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4216
4217    return ROK;
4218 }
4219
4220 /*******************************************************************
4221  *
4222  * @brief Builds intitial DL BWP
4223  * @details
4224  *
4225  *    Function : BuildInitialDlBWP
4226  *
4227  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4228  *
4229  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4230  *
4231  * @return ROK     - success
4232  *         RFAILED - failure
4233  *
4234  * ****************************************************************/
4235 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4236 {
4237    dlBwp->pdcch_Config = NULLP;
4238    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4239    if(!dlBwp->pdcch_Config)
4240    {
4241       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4242       return RFAILED;
4243    }
4244    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4245
4246    dlBwp->pdcch_Config->choice.setup = NULLP;
4247    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4248    if(!dlBwp->pdcch_Config->choice.setup)
4249    {
4250       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4251       return RFAILED;
4252    }
4253    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4254    {
4255       return RFAILED;
4256    }
4257
4258    dlBwp->pdsch_Config = NULLP;
4259    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4260    if(!dlBwp->pdsch_Config)
4261    {
4262       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4263       return RFAILED;
4264    }
4265    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4266
4267    dlBwp->pdsch_Config->choice.setup = NULLP;
4268    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4269    if(!dlBwp->pdsch_Config->choice.setup)
4270    {
4271       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4272       return RFAILED;
4273    }
4274
4275    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4276    {
4277       return RFAILED;
4278    }
4279
4280    dlBwp->sps_Config = NULLP;
4281    dlBwp->radioLinkMonitoringConfig = NULLP;
4282    return ROK;
4283 }
4284
4285 /*******************************************************************
4286  *
4287  * @brief Builds DMRS UL Pusch Mapping type A
4288  *
4289  * @details
4290  *
4291  *    Function : BuildDMRSULPuschMapTypeA
4292  *
4293  *    Functionality: Builds DMRS UL Pusch Mapping type A
4294  *
4295  * @params[in]
4296  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4297  * @return ROK     - success
4298  *         RFAILED - failure
4299  *
4300  * ****************************************************************/
4301    uint8_t BuildDMRSULPuschMapTypeA
4302 (
4303  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4304  )
4305 {
4306    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4307    dmrsUlCfg->choice.setup= NULLP;
4308    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4309    if(!dmrsUlCfg->choice.setup)
4310    {
4311       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4312       return RFAILED;
4313    }
4314
4315    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4316    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4317    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4318    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4319    {
4320       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4321       return RFAILED;
4322    }
4323    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4324
4325    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4326    dmrsUlCfg->choice.setup->maxLength = NULLP;
4327    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4328    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4329          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4330    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4331    {
4332       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4333       return RFAILED;
4334    }
4335
4336    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4337    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4338          sizeof(long));
4339    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4340    {
4341       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4342       return RFAILED;
4343    }
4344    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4345
4346    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4347    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4348    return ROK;
4349 }
4350
4351 /*******************************************************************
4352  *
4353  * @brief Build PUSCH time domain allocation list
4354  *
4355  * @details
4356  *
4357  *    Function : BuildPuschTimeDomAllocList
4358  *
4359  *    Functionality: Build PUSCH time domain allocation list
4360  *
4361  * @params[in]
4362  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4363  *
4364  * @return ROK     - success
4365  *         RFAILED - failure
4366  *
4367  * ****************************************************************/
4368    uint8_t BuildPuschTimeDomAllocList
4369 (
4370  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4371  )
4372 {
4373    uint8_t idx;
4374    uint8_t elementCnt;
4375    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4376
4377    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4378    timeDomAllocList->choice.setup = NULLP;
4379    DU_ALLOC(timeDomAllocList->choice.setup, \
4380          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4381    if(!timeDomAllocList->choice.setup)
4382    {
4383       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4384       return RFAILED;
4385    }
4386
4387    elementCnt = 2;
4388    timeDomAllocList->choice.setup->list.count = elementCnt;
4389    timeDomAllocList->choice.setup->list.size = \
4390                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4391    timeDomAllocList->choice.setup->list.array = NULLP;
4392    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4393          timeDomAllocList->choice.setup->list.size);
4394    if(!timeDomAllocList->choice.setup->list.array)
4395    {
4396       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4397       return RFAILED;
4398    }
4399
4400    for(idx = 0; idx < elementCnt; idx++)
4401    {
4402       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4403       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4404             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4405       if(!timeDomAllocList->choice.setup->list.array[idx])
4406       {
4407          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4408          return RFAILED;
4409       }
4410    }
4411
4412    idx = 0;
4413    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4414    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4415    if(!timeDomAlloc->k2)
4416    {
4417       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4418       return RFAILED;
4419    }
4420    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4421    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4422    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4423
4424    idx++;
4425    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4426    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4427    if(!timeDomAlloc->k2)
4428    {
4429       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4430       return RFAILED;
4431    }
4432    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4433    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4434    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4435
4436    return ROK;
4437 }
4438
4439 /*******************************************************************
4440  *
4441  * @brief Builds BWP UL dedicated PUSCH Config
4442  *
4443  * @details
4444  *
4445  *    Function : BuildBWPUlDedPuschCfg
4446  *
4447  *    Functionality:
4448  *      Builds BWP UL dedicated PUSCH Config
4449  *
4450  * @params[in] : PUSCH_Config_t *puschCfg
4451  *
4452  * @return ROK     - success
4453  *         RFAILED - failure
4454  *
4455  * ****************************************************************/
4456 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4457 {
4458    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4459    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4460    if(!puschCfg->dataScramblingIdentityPUSCH)
4461    {
4462       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4463       return RFAILED;
4464    }
4465    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4466
4467    puschCfg->txConfig = NULLP;
4468    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4469    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4470          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4471    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4472    {
4473       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4474       return RFAILED;
4475    }
4476
4477    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4478    {
4479       return RFAILED;
4480    }
4481
4482    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4483    puschCfg->pusch_PowerControl = NULLP;
4484    puschCfg->frequencyHopping = NULLP;
4485    puschCfg->frequencyHoppingOffsetLists = NULLP;
4486    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4487
4488    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4489    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4490          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4491    if(!puschCfg->pusch_TimeDomainAllocationList)
4492    {
4493       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4494       return RFAILED;
4495    }
4496
4497    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4498    {
4499       return RFAILED;
4500    }
4501
4502    puschCfg->pusch_AggregationFactor = NULLP;
4503    puschCfg->mcs_Table = NULLP;
4504    puschCfg->mcs_TableTransformPrecoder = NULLP;
4505    puschCfg->transformPrecoder = NULLP;
4506    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4507    if(!puschCfg->transformPrecoder)
4508    {
4509       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4510       return RFAILED;
4511    }
4512    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4513
4514    puschCfg->codebookSubset = NULLP;
4515    puschCfg->maxRank = NULLP;
4516    puschCfg->rbg_Size = NULLP;
4517    puschCfg->uci_OnPUSCH = NULLP;
4518    puschCfg->tp_pi2BPSK = NULLP;
4519
4520    return ROK;
4521 }
4522
4523 /*******************************************************************
4524  *
4525  * @brief Builds BWP UL dedicated PUCCH Config
4526  *
4527  * @details
4528  *
4529  *    Function : BuildBWPUlDedPucchCfg
4530  *
4531  *    Functionality:
4532  *      Builds BWP UL dedicated PUCCH Config
4533  *
4534  * @params[in] : PUCCH_Config_t *pucchCfg
4535  *
4536  * @return ROK     - success
4537  *         RFAILED - failure
4538  *
4539  * ****************************************************************/
4540 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4541 {
4542    uint8_t arrIdx, elementCnt;
4543    uint8_t rsrcIdx, rsrcSetIdx;
4544    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4545    PUCCH_Resource_t *rsrc = NULLP;
4546
4547    //RESOURCE SET
4548    elementCnt = 1;
4549    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4550    if(pucchCfg->resourceSetToAddModList == NULL)
4551    {
4552       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4553       return RFAILED;
4554    }
4555
4556    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4557    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4558    DU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4559    if(pucchCfg->resourceSetToAddModList->list.array == NULLP)
4560    {
4561       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4562       return RFAILED;
4563    }
4564    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4565    {
4566       DU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4567       if(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4568       {
4569          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4570          return RFAILED;
4571       }
4572    }
4573    rsrcSetIdx = 0;
4574    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4575    rsrcSet->pucch_ResourceSetId = 1;
4576    elementCnt = 1;
4577    rsrcSet->resourceList.list.count = elementCnt;
4578    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4579    DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4580    if(rsrcSet->resourceList.list.array == NULLP)
4581    {
4582       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4583       return RFAILED;
4584    }
4585    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4586    {
4587       DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4588       if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4589       {
4590          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4591          return RFAILED;
4592       }
4593    }
4594    rsrcIdx = 0;
4595    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4596
4597    //RESOURCE
4598    elementCnt = 1;
4599    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4600    if(pucchCfg->resourceToAddModList == NULLP)
4601    {
4602       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4603       return RFAILED;
4604    }
4605    pucchCfg->resourceToAddModList->list.count = elementCnt;
4606    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4607    DU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4608    if(pucchCfg->resourceToAddModList->list.array == NULLP)
4609    {
4610       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4611       return RFAILED;
4612    }
4613    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4614    {
4615       DU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4616       if(pucchCfg->resourceToAddModList->list.array[rsrcIdx] == NULLP)
4617       {
4618          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4619          return RFAILED;
4620       }
4621    }
4622    rsrcIdx = 0;
4623    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4624    rsrc->pucch_ResourceId = 1;
4625    rsrc->startingPRB = 0;
4626    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4627    DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4628    if(rsrc->format.choice.format1 == NULLP)
4629    {
4630       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4631       return RFAILED;
4632    }
4633    rsrc->format.choice.format1->initialCyclicShift = 0;
4634    rsrc->format.choice.format1->nrofSymbols = 4;
4635    rsrc->format.choice.format1->startingSymbolIndex = 0;
4636    rsrc->format.choice.format1->timeDomainOCC = 0;
4637
4638    //PUCCH Format 1
4639    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4640    if(pucchCfg->format1 == NULLP)
4641    {
4642       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4643       return RFAILED;
4644    }
4645    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4646    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4647    if(pucchCfg->format1->choice.setup == NULLP)
4648    {
4649       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4650       return RFAILED;
4651    }
4652    DU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4653    if(pucchCfg->format1->choice.setup->nrofSlots == NULLP)
4654    {
4655       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4656       return RFAILED;
4657    }
4658    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4659
4660    //DL DATA TO UL ACK
4661    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4662    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4663    {
4664       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4665       return RFAILED;
4666    }
4667
4668    elementCnt = 2;
4669    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4670    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4671    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4672    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4673    {
4674       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4675       return RFAILED;
4676    }
4677
4678    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4679    {
4680       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4681       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4682       {
4683           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4684           return RFAILED;
4685       }
4686    }
4687
4688    arrIdx = 0;
4689    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4690    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4691    return ROK;
4692 }
4693
4694 /*******************************************************************
4695  *
4696  * @brief Fills SRS resource to add/modify list
4697  *
4698  * @details
4699  *
4700  *    Function : BuildSrsRsrcAddModList
4701  *
4702  *    Functionality: Fills SRS resource to add/modify list
4703  *
4704  * @params[in]
4705  * @return ROK     - success
4706  *         RFAILED - failure
4707  *
4708  * ****************************************************************/
4709 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4710 {
4711    uint8_t   elementCnt;
4712    uint8_t   rsrcIdx;
4713
4714    elementCnt = 1;
4715    resourceList->list.count = elementCnt;
4716    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4717    resourceList->list.array = NULLP;
4718    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4719    if(!resourceList->list.array)
4720    {
4721       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4722       return RFAILED;
4723    }
4724
4725    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4726    {
4727       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4728       if(!resourceList->list.array[rsrcIdx])
4729       {
4730          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4731          return RFAILED;
4732       }
4733    }
4734
4735    rsrcIdx = 0;
4736    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4737    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4738    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4739
4740    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4741    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4742          sizeof(struct SRS_Resource__transmissionComb__n2));
4743    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4744    {
4745       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4746       return RFAILED;
4747    }
4748    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4749       = SRS_COMB_OFFSET_N2;
4750    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4751       = SRS_CYCLIC_SHIFT_N2;
4752
4753    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4754                                                                       PUSCH_START_SYMBOL;
4755    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4756                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4757    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4758                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4759
4760    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4761    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4762    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4763    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4764    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4765    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4766                                                                SRS_Resource__groupOrSequenceHopping_neither;
4767
4768    /* Setting resource type to aperiodic for intergration purposes */
4769    resourceList->list.array[rsrcIdx]->resourceType.present = \
4770                                                              SRS_Resource__resourceType_PR_aperiodic;
4771    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4772    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4773          sizeof(struct SRS_Resource__resourceType__aperiodic));
4774    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4775    {
4776       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4777       return RFAILED;
4778    }
4779    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4780
4781    return ROK;
4782 }
4783
4784 /*******************************************************************
4785  *
4786  * @brief Build SRS resource set Add/mod list
4787  *
4788  * @details
4789  *
4790  *    Function : BuildSrsRsrcSetAddModList
4791  *
4792  *    Functionality: Build SRS resource set Add/mod list
4793  *
4794  * @params[in]
4795  * @return ROK     - success
4796  *         RFAILED - failure
4797  *
4798  * ****************************************************************/
4799    uint8_t BuildSrsRsrcSetAddModList
4800 (
4801  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4802  )
4803 {
4804    uint8_t  elementCnt;
4805    uint8_t  rSetIdx;
4806    uint8_t  rsrcIdx;
4807    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4808
4809    elementCnt = 1;
4810    rsrcSetList->list.count = elementCnt;
4811    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4812    rsrcSetList->list.array = NULLP;
4813    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4814    if(!rsrcSetList->list.array)
4815    {
4816       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4817       return RFAILED;
4818    }
4819
4820    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4821    {
4822       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4823       if(!rsrcSetList->list.array[rSetIdx])
4824       {
4825          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4826          return RFAILED;
4827       }
4828    }
4829
4830    rSetIdx = 0;
4831    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4832
4833    /* Fill Resource Id list in resource set */
4834    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4835    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4836          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4837    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4838    {
4839       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4840       return RFAILED;
4841    }
4842
4843    elementCnt = 1;
4844    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4845    rsrcIdList->list.count = elementCnt;
4846    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4847    rsrcIdList->list.array = NULLP;
4848    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4849    if(!rsrcIdList->list.array)
4850    {
4851       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4852       return RFAILED;
4853    }
4854
4855    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4856    {
4857       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4858       if(!rsrcIdList->list.array[rsrcIdx])
4859       {
4860          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4861          return RFAILED;
4862       }
4863    }
4864
4865    rsrcIdx = 0;
4866    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4867
4868    /* Fill resource type */
4869    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4870                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4871
4872    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4873    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4874          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4875    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4876    {
4877       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4878       return RFAILED;
4879    }
4880    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4881       = APERIODIC_SRS_RESRC_TRIGGER;
4882
4883    /* TODO : Fill values for below IEs as expected by Viavi */
4884    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4885    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4886
4887
4888    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4889    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4890    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4891    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4892    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4893
4894    return ROK;
4895 }
4896
4897 /*******************************************************************
4898  *
4899  * @brief Builds BWP UL dedicated SRS Config
4900  *
4901  * @details
4902  *
4903  *    Function : BuildBWPUlDedSrsCfg
4904  *
4905  *    Functionality: Builds BWP UL dedicated SRS Config
4906  *
4907  * @params[in] SRS Config
4908  * @return ROK     - success
4909  *         RFAILED - failure
4910  *
4911  * ****************************************************************/
4912 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4913 {
4914    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4915    srsCfg->srs_ResourceSetToAddModList = NULLP;
4916    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4917          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4918    if(!srsCfg->srs_ResourceSetToAddModList)
4919    {
4920       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4921       return RFAILED;
4922    }
4923    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4924    {
4925       return RFAILED;
4926    }
4927
4928    srsCfg->srs_ResourceToReleaseList = NULLP;
4929
4930    /* Resource to Add/Modify list */
4931    srsCfg->srs_ResourceToAddModList = NULLP;
4932    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4933          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4934    if(!srsCfg->srs_ResourceToAddModList)
4935    {
4936       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4937       return RFAILED;
4938    }
4939
4940    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4941    {
4942       return RFAILED;
4943    }
4944
4945    srsCfg->tpc_Accumulation = NULLP;
4946
4947    return ROK;
4948 }
4949
4950
4951
4952 /*******************************************************************
4953  *
4954  * @brief Builds Pusch Serving cell Config
4955  *
4956  * @details
4957  *
4958  *    Function : BuildPuschSrvCellCfg
4959  *
4960  *    Functionality: Builds Pusch Serving cell Config
4961  *
4962  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4963  *
4964  * @return ROK     - success
4965  *         RFAILED - failure
4966  *
4967  * ****************************************************************/
4968 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4969 {
4970    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4971    puschCfg->choice.setup = NULLP;
4972    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4973    if(!puschCfg->choice.setup)
4974    {
4975       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4976       return RFAILED;
4977    }
4978
4979    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4980    puschCfg->choice.setup->rateMatching = NULLP;
4981    puschCfg->choice.setup->xOverhead = NULLP;
4982    puschCfg->choice.setup->ext1 = NULLP;
4983    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4984    if(!puschCfg->choice.setup->ext1)
4985    {
4986       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4987       return RFAILED;
4988    }
4989
4990    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4991    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4992    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4993    {
4994       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4995       return RFAILED;
4996    }
4997    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4998
4999    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5000    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5001    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5002    {
5003       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5004       return RFAILED;
5005    }
5006    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5007    return ROK;
5008 }
5009
5010 /*******************************************************************
5011  *
5012  * @brief Builds inital UL BWP
5013  *
5014  * @details
5015  *
5016  *    Function : BuildInitialUlBWP
5017  *
5018  *    Functionality: Builds initial UL BWP
5019  *
5020  * @params[in] BWP_UplinkDedicated_t *ulBwp
5021  * @return ROK     - success
5022  *         RFAILED - failure
5023  *
5024  * ****************************************************************/
5025 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5026 {
5027    ulBwp->pucch_Config = NULLP;
5028    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5029    if(!ulBwp->pucch_Config)
5030    {
5031       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5032       return RFAILED;
5033    }
5034
5035    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
5036    ulBwp->pucch_Config->choice.setup = NULLP;
5037    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5038    if(!ulBwp->pucch_Config->choice.setup)
5039    {
5040       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5041       return RFAILED;
5042    }
5043
5044    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
5045    {
5046       return RFAILED;
5047    }
5048
5049    /* Fill BWP UL dedicated PUSCH config */
5050    ulBwp->pusch_Config = NULLP;
5051    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5052    if(!ulBwp->pusch_Config)
5053    {
5054       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5055       return RFAILED;
5056    }
5057
5058    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
5059    ulBwp->pusch_Config->choice.setup = NULLP;
5060    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5061    if(!ulBwp->pusch_Config->choice.setup)
5062    {
5063       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5064       return RFAILED;
5065    }
5066
5067    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
5068    {
5069       return RFAILED;
5070    }
5071
5072    ulBwp->configuredGrantConfig = NULLP;
5073
5074    /* Fill BPW UL dedicated SRS config */
5075    ulBwp->srs_Config = NULLP;
5076    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5077    if(!ulBwp->srs_Config)
5078    {
5079       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5080       return RFAILED;
5081    }
5082
5083    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
5084    ulBwp->srs_Config->choice.setup = NULLP;
5085    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5086    if(!ulBwp->srs_Config->choice.setup)
5087    {
5088       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5089       return RFAILED;
5090    }
5091
5092    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
5093    {
5094       return RFAILED;
5095    }
5096
5097    ulBwp->beamFailureRecoveryConfig = NULLP;
5098
5099    return ROK;
5100 }
5101
5102 /*******************************************************************
5103  *
5104  * @brief Builds UL config
5105  * @details
5106  *
5107  *    Function : BuildUlCfg
5108  *
5109  *    Functionality: Builds UL config in spCellCfgDed
5110  *
5111  * @params[in] UplinkConfig_t *ulCfg
5112  *
5113  * @return ROK     - success
5114  *         RFAILED - failure
5115  *
5116  * ****************************************************************/
5117 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
5118 {
5119    ulCfg->initialUplinkBWP = NULLP;
5120    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5121    if(!ulCfg->initialUplinkBWP)
5122    {
5123       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5124       return RFAILED;
5125    }
5126
5127    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
5128    {
5129       return RFAILED;
5130    }
5131
5132    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5133    ulCfg->uplinkBWP_ToAddModList = NULLP;
5134    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5135    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5136    if(!ulCfg->firstActiveUplinkBWP_Id)
5137    {
5138       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5139       return RFAILED;
5140    }
5141    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5142
5143    ulCfg->pusch_ServingCellConfig = NULLP;
5144    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
5145          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5146    if(!ulCfg->pusch_ServingCellConfig)
5147    {
5148       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5149       return RFAILED;
5150    }
5151
5152    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5153    {
5154       return RFAILED;
5155    }
5156
5157    ulCfg->carrierSwitching = NULLP;
5158    ulCfg->ext1 = NULLP;
5159    return ROK;
5160 }
5161
5162 /*******************************************************************
5163  *
5164  * @brief Builds PDSCH serving cell config
5165  * @details
5166  *
5167  *    Function : BuildPdschSrvCellCfg
5168  *
5169  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5170  *
5171  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5172  *
5173  * @return ROK     - success
5174  *         RFAILED - failure
5175  *
5176  * ****************************************************************/
5177 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5178 {
5179    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5180    pdschCfg->choice.setup = NULLP;
5181    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5182    if(!pdschCfg->choice.setup)
5183    {
5184       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5185       return RFAILED;
5186    }
5187
5188    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5189    pdschCfg->choice.setup->xOverhead = NULLP;
5190    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5191    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5192    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5193    {
5194       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5195       return RFAILED;
5196    }
5197    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
5198    pdschCfg->choice.setup->pucch_Cell = NULLP;
5199    pdschCfg->choice.setup->ext1 = NULLP;
5200
5201    return ROK;
5202 }
5203
5204 /*******************************************************************
5205  *
5206  * @brief Builds CSI Meas config
5207  * @details
5208  *
5209  *    Function : BuildCsiMeasCfg
5210  *
5211  *    Functionality: Builds CSI Meas config in spCellCfgDed
5212  *
5213  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5214  *
5215  * @return ROK     - success
5216  *         RFAILED - failure
5217  *
5218  * ****************************************************************/
5219 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5220 {
5221
5222    return ROK;
5223 }
5224
5225 /*******************************************************************
5226  *
5227  * @brief Builds Spcell config dedicated
5228  * @details
5229  *
5230  *    Function : BuildSpCellCfgDed
5231  *
5232  *    Functionality: Builds sp cell config dedicated in spCellCfg
5233  *
5234  * @params[in] ServingCellConfig_t srvCellCfg
5235  *
5236  * @return ROK     - success
5237  *         RFAILED - failure
5238  *
5239  * ****************************************************************/
5240 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
5241 {
5242    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
5243    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5244    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5245    {
5246       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5247       return RFAILED;
5248    }
5249
5250    srvCellCfg->initialDownlinkBWP = NULLP;
5251    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5252    if(!srvCellCfg->initialDownlinkBWP)
5253    {
5254       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5255       return RFAILED;
5256    }
5257
5258    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
5259    {
5260       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
5261       return RFAILED;
5262    }
5263    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
5264    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
5265
5266    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
5267    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5268    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
5269    {
5270       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5271       return RFAILED;
5272    }
5273    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5274
5275    srvCellCfg->bwp_InactivityTimer = NULLP;
5276
5277    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
5278    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5279    if(!srvCellCfg->defaultDownlinkBWP_Id)
5280    {
5281       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5282       return RFAILED;
5283    }
5284    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5285
5286    srvCellCfg->uplinkConfig = NULLP;
5287    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5288    if(!srvCellCfg->uplinkConfig)
5289    {
5290       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5291       return RFAILED;
5292    }
5293
5294    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
5295    {
5296       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
5297       return RFAILED;
5298    }
5299    srvCellCfg->supplementaryUplink = NULLP;
5300    srvCellCfg->pdcch_ServingCellConfig = NULLP;
5301
5302    srvCellCfg->pdsch_ServingCellConfig = NULLP;
5303    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
5304    if(!srvCellCfg->pdsch_ServingCellConfig)
5305    {
5306       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5307       return RFAILED;
5308    }
5309
5310    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
5311    {
5312       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
5313       return RFAILED;
5314    }
5315
5316    srvCellCfg->csi_MeasConfig = NULLP;
5317 #if 0
5318    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
5319       if(!srvCellCfg->csi_MeasConfig)
5320       {
5321          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5322          return RFAILED;
5323       }
5324
5325    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
5326    {
5327       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
5328       return RFAILED;
5329    }
5330 #endif
5331    srvCellCfg->sCellDeactivationTimer = NULLP;
5332    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
5333    srvCellCfg->tag_Id = TAG_ID;
5334    srvCellCfg->dummy = NULLP;
5335    srvCellCfg->pathlossReferenceLinking = NULLP;
5336    srvCellCfg->servingCellMO = NULLP;
5337    srvCellCfg->ext1 = NULLP;
5338
5339    return ROK;
5340 }
5341 /*******************************************************************
5342  *
5343  * @brief Builds Spcell config
5344  *
5345  * @details
5346  *
5347  *    Function : BuildSpCellCfg
5348  *
5349  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5350  *
5351  * @params[in] SpCellConfig_t spCellCfg
5352  *
5353  * @return ROK     - success
5354  *         RFAILED - failure
5355  *
5356  * ****************************************************************/
5357 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5358 {
5359
5360    spCellCfg->servCellIndex = NULLP;
5361    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5362    if(!spCellCfg->servCellIndex)
5363    {
5364       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5365       return RFAILED;
5366    }
5367    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5368
5369    spCellCfg->reconfigurationWithSync = NULLP;
5370    spCellCfg->rlf_TimersAndConstants = NULLP;
5371    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5372    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5373    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5374    {
5375       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5376       return RFAILED;
5377    }
5378    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5379
5380    spCellCfg->spCellConfigDedicated = NULLP;
5381    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5382    if(!spCellCfg->spCellConfigDedicated)
5383    {
5384       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5385       return RFAILED;
5386    }
5387    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5388    {
5389       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5390       return RFAILED;
5391    }
5392    return ROK;
5393 }
5394 /*******************************************************************
5395  *
5396  * @brief Builds Phy cell group config
5397  *
5398  * @details
5399  *
5400  *    Function : BuildPhyCellGrpCfg
5401  *
5402  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5403  *
5404  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5405  *
5406  * @return ROK     - success
5407  *         RFAILED - failure
5408  *
5409  * ****************************************************************/
5410 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5411 {
5412    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5413    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5414
5415    phyCellGrpCfg->p_NR_FR1 = NULLP;
5416    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5417    if(!phyCellGrpCfg->p_NR_FR1)
5418    {
5419       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5420       return RFAILED;
5421    }
5422    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5423    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5424    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5425    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5426    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5427    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5428    phyCellGrpCfg->cs_RNTI = NULLP;
5429    phyCellGrpCfg->ext1 = NULLP;
5430    phyCellGrpCfg->ext2 = NULLP;
5431
5432    return ROK;
5433 }
5434 /*******************************************************************
5435  *
5436  * @brief Builds Mac cell group config
5437  *
5438  * @details
5439  *
5440  *    Function : BuildMacCellGrpCfg
5441  *
5442  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5443  *
5444  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5445  *
5446  * @return ROK     - success
5447  *         RFAILED - failure
5448  *
5449  * ****************************************************************/
5450 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5451 {
5452    macCellGrpCfg->drx_Config = NULLP;
5453    macCellGrpCfg->schedulingRequestConfig = NULLP;
5454    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5455    if(!macCellGrpCfg->schedulingRequestConfig)
5456    {
5457       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5458       return RFAILED;
5459    }
5460
5461    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5462    {
5463       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5464       return RFAILED;
5465    }
5466
5467    macCellGrpCfg->bsr_Config = NULLP;
5468    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5469    if(!macCellGrpCfg->bsr_Config)
5470    {
5471       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5472       return RFAILED;
5473    }
5474
5475    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5476    {
5477       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5478       return RFAILED;
5479    }
5480
5481    macCellGrpCfg->tag_Config = NULLP;
5482    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5483    if(!macCellGrpCfg->tag_Config)
5484    {
5485       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5486       return RFAILED;
5487    }
5488
5489    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5490    {
5491       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5492       return RFAILED;
5493    }
5494
5495    macCellGrpCfg->phr_Config = NULLP;
5496    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5497    if(!macCellGrpCfg->phr_Config)
5498    {
5499       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5500       return RFAILED;
5501    }
5502
5503    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5504    {
5505       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5506       return RFAILED;
5507    }
5508
5509    macCellGrpCfg->skipUplinkTxDynamic = false;
5510    macCellGrpCfg->ext1 = NULLP;
5511
5512    return ROK;
5513 }
5514 /*******************************************************************
5515  *
5516  * @brief Frees memeory allocated for SearchSpcToAddModList
5517  *
5518  * @details
5519  *
5520  *    Function : FreeSearchSpcToAddModList
5521  *
5522  *    Functionality: Deallocating memory of SearchSpcToAddModList
5523  *
5524  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5525  *
5526  * @return void
5527  *
5528  4221 * ****************************************************************/
5529 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5530 {
5531    uint8_t idx1=0;
5532    uint8_t idx2=0;
5533    struct  SearchSpace *searchSpc=NULLP;
5534
5535    if(searchSpcList->list.array)
5536    {
5537       if(searchSpcList->list.array[idx2])
5538       {
5539          searchSpc = searchSpcList->list.array[idx2];
5540          if(searchSpc->controlResourceSetId)
5541          {
5542             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5543             {
5544                if(searchSpc->monitoringSymbolsWithinSlot)
5545                {
5546                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5547                   {
5548                      if(searchSpc->nrofCandidates)
5549                      {
5550                         if(searchSpc->searchSpaceType)
5551                         {
5552                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5553                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5554                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5555                                     SearchSpace__searchSpaceType));
5556                         }
5557                         DU_FREE(searchSpc->nrofCandidates,
5558                               sizeof(struct SearchSpace__nrofCandidates));
5559                      }
5560                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5561                            searchSpc->monitoringSymbolsWithinSlot->size);
5562                   }
5563                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5564                         sizeof(BIT_STRING_t));
5565                }
5566                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5567                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5568             }
5569             DU_FREE(searchSpc->controlResourceSetId,
5570                   sizeof(ControlResourceSetId_t));
5571          }
5572       }
5573       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5574       {
5575          DU_FREE(searchSpcList->list.array[idx1],
5576                sizeof(struct SearchSpace));
5577       }
5578       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5579    }
5580 }
5581 /*******************************************************************
5582  *
5583  * @brief Frees memory allocated for PdschTimeDomAllocList
5584  *
5585  * @details
5586  *
5587  *    Function : FreePdschTimeDomAllocList
5588  *
5589  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5590  *
5591  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5592  *
5593  * @return void
5594  *
5595  * ****************************************************************/
5596 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5597 {
5598    uint8_t idx1=0;
5599
5600    if(timeDomAllocList->choice.setup)
5601    {
5602       if(timeDomAllocList->choice.setup->list.array)
5603       {
5604          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5605          {
5606             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5607             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5608                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5609          }
5610          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5611                timeDomAllocList->choice.setup->list.size);
5612       }
5613       DU_FREE(timeDomAllocList->choice.setup,\
5614             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5615    }
5616 }
5617 /*******************************************************************
5618  *
5619  * @brief Frees memory allocated for PuschTimeDomAllocList
5620  *
5621  *@details
5622  *
5623  *    Function : FreePuschTimeDomAllocList
5624  *
5625  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5626  *
5627  * @params[in] PUSCH_Config_t *puschCfg
5628  *
5629  * @return void
5630  *
5631  * ****************************************************************/
5632 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5633 {
5634    uint8_t rsrcListIdx=0;
5635    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5636
5637    if(puschCfg->pusch_TimeDomainAllocationList)
5638    {
5639       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5640       if(timeDomAllocList_t->choice.setup)
5641       {
5642          if(timeDomAllocList_t->choice.setup->list.array)
5643          {
5644             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5645             {
5646                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5647                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5648                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5649             }
5650             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5651                   timeDomAllocList_t->choice.setup->list.size);
5652          }
5653          DU_FREE(timeDomAllocList_t->choice.setup, \
5654                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5655       }
5656       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5657       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5658             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5659    }
5660
5661 }
5662
5663 /*******************************************************************
5664  *
5665  * @brief Frees memory allocated for Dedicated PUCCH config
5666  *
5667  * @details
5668  *
5669  *    Function : FreeBWPUlDedPucchCfg
5670  *
5671  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5672  *
5673  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5674  *
5675  * @return void
5676  *
5677  * ****************************************************************/
5678 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5679 {
5680    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
5681    PUCCH_Config_t *pucchCfg = NULLP;
5682    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5683    PUCCH_Resource_t *rsrc = NULLP;
5684
5685    if(ulBwpPucchCfg)
5686    {
5687       if(ulBwpPucchCfg->choice.setup)
5688       {
5689          pucchCfg = ulBwpPucchCfg->choice.setup;
5690
5691          //Free resource set list
5692          if(pucchCfg->resourceSetToAddModList)
5693          {
5694             if(pucchCfg->resourceSetToAddModList->list.array)
5695             {
5696                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5697                {
5698                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5699                   if(rsrcSet->resourceList.list.array)
5700                   {
5701                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5702                      {
5703                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5704                      }
5705                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5706                   }
5707                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5708                }
5709                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5710             }
5711             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5712          }
5713
5714          //Free resource list
5715          if(pucchCfg->resourceToAddModList)
5716          {
5717             if(pucchCfg->resourceToAddModList->list.array)
5718             {
5719                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5720                {
5721                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5722                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5723                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5724                }
5725                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5726             }
5727             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5728          }
5729
5730          //PUCCH Format 1
5731          if(pucchCfg->format1)
5732          {
5733             if(pucchCfg->format1->choice.setup)
5734             {
5735                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5736                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5737             }
5738             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5739          }
5740
5741          //DL DATA TO UL ACK
5742          if(pucchCfg->dl_DataToUL_ACK)
5743          {
5744             if(pucchCfg->dl_DataToUL_ACK->list.array)
5745             {
5746                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5747                {
5748                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5749                }
5750                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5751             }
5752             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5753          }
5754
5755          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5756       }
5757       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5758    }
5759 }
5760
5761 /*******************************************************************
5762  *
5763  * @brief Frees memory allocated for InitialUlBWP
5764  *
5765  * @details
5766  *
5767  *    Function : FreeInitialUlBWP
5768  *
5769  *    Functionality: Deallocating memory of InitialUlBWP
5770  *
5771  * @params[in] BWP_UplinkDedicated_t *ulBwp
5772  *
5773  * @return void
5774  *
5775  * ****************************************************************/
5776 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5777 {
5778    uint8_t  rSetIdx, rsrcIdx;
5779    SRS_Config_t   *srsCfg = NULLP;
5780    PUSCH_Config_t *puschCfg = NULLP;
5781    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5782    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5783    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5784    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5785
5786    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5787
5788    if(ulBwp->pusch_Config)
5789    {
5790       if(ulBwp->pusch_Config->choice.setup)
5791       {
5792          puschCfg=ulBwp->pusch_Config->choice.setup;
5793          if(puschCfg->dataScramblingIdentityPUSCH)
5794          {
5795             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5796             {
5797                FreePuschTimeDomAllocList(puschCfg);
5798                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5799                if(dmrsUlCfg->choice.setup)
5800                {
5801                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5802                   {
5803                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5804                      {
5805                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5806                               sizeof(long));
5807                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5808                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5809                      }
5810                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5811                            sizeof(long));
5812                   }
5813                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5814                }
5815                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5816                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5817             }
5818             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5819          }
5820          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5821       }
5822       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5823
5824       /* Free SRS-Config */
5825       if(ulBwp->srs_Config)
5826       {
5827          if(ulBwp->srs_Config->choice.setup)
5828          {
5829             srsCfg = ulBwp->srs_Config->choice.setup;
5830
5831             /* Free Resource Set to add/mod list */
5832             if(srsCfg->srs_ResourceSetToAddModList)
5833             {
5834                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5835                if(rsrcSetList->list.array)
5836                {
5837                   rSetIdx = 0;
5838
5839                   /* Free SRS resource Id list in this SRS resource set */
5840                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5841                   {
5842                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5843
5844                      if(rsrcIdList->list.array)
5845                      {
5846                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5847                         {
5848                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5849                         }
5850                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5851                      }
5852                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5853                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5854                   }
5855
5856                   /* Free resource type info for this SRS resource set */
5857                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5858                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5859
5860                   /* Free memory for each resource set */
5861                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5862                   {
5863                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5864                   }
5865                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5866                }
5867                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5868                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5869             }
5870
5871             /* Free resource to add/modd list */
5872             if(srsCfg->srs_ResourceToAddModList)
5873             {
5874                resourceList = srsCfg->srs_ResourceToAddModList;
5875                if(resourceList->list.array)
5876                {
5877                   rsrcIdx = 0;
5878                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5879                         sizeof(struct SRS_Resource__transmissionComb__n2));
5880                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5881                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5882
5883                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5884                   {
5885                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5886                   }
5887                   DU_FREE(resourceList->list.array, resourceList->list.size);
5888                }
5889                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5890                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5891             }
5892
5893             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5894          }
5895          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5896       }
5897    }
5898 }
5899 /*******************************************************************
5900  *
5901  * @brief Frees memory allocated for initialUplinkBWP
5902  *
5903  * @details
5904  *
5905  *    Function : FreeinitialUplinkBWP
5906  *
5907  *    Functionality: Deallocating memory of initialUplinkBWP
5908  *
5909  * @params[in] UplinkConfig_t *ulCfg
5910  *
5911  * @return void
5912  *
5913  *
5914  * ****************************************************************/
5915 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5916 {
5917    BWP_UplinkDedicated_t *ulBwp=NULLP;
5918    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5919
5920    if(ulCfg->initialUplinkBWP)
5921    {
5922       ulBwp=ulCfg->initialUplinkBWP;
5923       if(ulCfg->firstActiveUplinkBWP_Id)
5924       {
5925          if(ulCfg->pusch_ServingCellConfig)
5926          {
5927             puschCfg=ulCfg->pusch_ServingCellConfig;
5928             if(puschCfg->choice.setup)
5929             {
5930                if(puschCfg->choice.setup->ext1)
5931                {
5932                   DU_FREE(puschCfg->choice.setup->ext1->\
5933                         processingType2Enabled,sizeof(BOOLEAN_t));
5934                   DU_FREE(puschCfg->choice.setup->ext1->\
5935                         maxMIMO_Layers,sizeof(long));
5936                   DU_FREE(puschCfg->choice.setup->ext1, \
5937                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5938                }
5939                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5940             }
5941             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5942          }
5943          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5944       }
5945       FreeInitialUlBWP(ulBwp);
5946       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5947    }
5948 }
5949 /*******************************************************************
5950  *
5951  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5952  *
5953  * @details
5954  *
5955  *    Function : FreeBWPDlDedPdschCfg
5956  *
5957  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5958  *
5959  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5960  *
5961  * @return void
5962  *
5963  *
5964  * ****************************************************************/
5965 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5966 {
5967    struct PDSCH_Config *pdschCfg=NULLP;
5968    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5969    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5970    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5971
5972    if(dlBwp->pdsch_Config->choice.setup)
5973    {
5974       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5975       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5976       {
5977          if(pdschCfg->pdsch_TimeDomainAllocationList)
5978          {
5979             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5980             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5981             {
5982                prbBndlType=&pdschCfg->prb_BundlingType;
5983                DU_FREE(prbBndlType->choice.staticBundling,\
5984                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5985                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5986             }
5987             FreePdschTimeDomAllocList(timeDomAllocList);
5988             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5989                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5990          }
5991          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5992          if(dmrsDlCfg->choice.setup)
5993          {
5994             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5995                   sizeof(long));
5996             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5997          }
5998          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5999                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6000       }
6001       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6002    }
6003 }
6004 /*******************************************************************
6005  *
6006  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6007  *
6008  * @details
6009  *
6010  *    Function : FreeBWPDlDedPdcchCfg
6011  *
6012  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6013  *
6014  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6015  *
6016  * @return void
6017  *
6018  *
6019  * ****************************************************************/
6020 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6021 {
6022    uint8_t idx1=0;
6023    uint8_t idx2=0;
6024    struct PDCCH_Config *pdcchCfg=NULLP;
6025    struct ControlResourceSet *controlRSet=NULLP;
6026    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6027
6028    if(dlBwp->pdcch_Config->choice.setup)
6029    {
6030       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6031       if(pdcchCfg->controlResourceSetToAddModList)
6032       {
6033          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6034          if(controlRSetList->list.array)
6035          {
6036             controlRSet = controlRSetList->list.array[idx2];
6037             if(controlRSet)
6038             {
6039                if(controlRSet->frequencyDomainResources.buf)
6040                {
6041                   if(controlRSet->pdcch_DMRS_ScramblingID)
6042                   {
6043                      if(pdcchCfg->searchSpacesToAddModList)
6044                      {
6045                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6046                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
6047                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6048                      }
6049                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6050                   }
6051                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
6052                         controlRSet->frequencyDomainResources.size);
6053                }
6054             }
6055             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6056             {
6057                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6058             }
6059             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6060          }
6061          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6062                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6063       }
6064       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6065    }
6066 }
6067
6068 /*******************************************************************
6069  *
6070  * @brief Frees emmory allocated for DUToCURRCContainer
6071  *
6072  * @details
6073  *
6074  *    Function : FreeMemDuToCuRrcCont
6075  *
6076  *    Functionality: Deallocating memory of DuToCuRrcContainer
6077  *
6078  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
6079  *
6080  * @return ROK     - success
6081  *         RFAILED - failure
6082  *
6083  * ****************************************************************/
6084 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
6085 {
6086    uint8_t idx=0;
6087    SpCellConfig_t *spCellCfg=NULLP;
6088    ServingCellConfig_t *srvCellCfg=NULLP;
6089    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6090    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6091    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6092    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6093    struct RLC_Config *rlcConfig=NULLP;
6094    struct LogicalChannelConfig *macLcConfig=NULLP;
6095    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6096    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6097    struct TAG_Config *tagConfig=NULLP;
6098    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6099    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6100    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6101
6102    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6103    if(rlcBearerList)
6104    {
6105       if(rlcBearerList->list.array)
6106       {
6107          for(idx=0; idx<rlcBearerList->list.count; idx++)
6108          {
6109             if(rlcBearerList->list.array[idx])
6110             {
6111                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6112                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6113                if(rlcConfig)
6114                {
6115                   if(rlcConfig->choice.am)
6116                   {
6117                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6118                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6119                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6120                   }
6121                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
6122                }
6123                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6124                if(macLcConfig)
6125                {
6126                   if(macLcConfig->ul_SpecificParameters)
6127                   {
6128                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6129                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6130                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6131                   }
6132                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6133                }
6134                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6135             }
6136          }
6137          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6138       }
6139       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6140    }
6141
6142    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6143    if(macCellGrpCfg)
6144    {
6145       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6146       if(schedulingRequestConfig)
6147       {
6148          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6149          if(schReqList)
6150          {
6151             if(schReqList->list.array)
6152             {
6153                for(idx=0;idx<schReqList->list.count; idx++)
6154                {
6155                   if(schReqList->list.array[idx])
6156                   {
6157                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6158                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6159                   }
6160                }
6161                DU_FREE(schReqList->list.array, schReqList->list.size);
6162             }
6163             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6164                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6165             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6166       }
6167       if(macCellGrpCfg->bsr_Config)
6168       {
6169          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6170       }
6171       tagConfig = macCellGrpCfg->tag_Config;
6172       if(tagConfig)
6173       {
6174          tagList = tagConfig->tag_ToAddModList;
6175          if(tagList)
6176          {
6177             if(tagList->list.array)
6178             {
6179                for(idx=0; idx<tagList->list.count; idx++)
6180                {
6181                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6182                }
6183                DU_FREE(tagList->list.array, tagList->list.size);
6184             }
6185             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6186          }
6187          DU_FREE(tagConfig, sizeof(struct TAG_Config));
6188       }
6189
6190       phrConfig = macCellGrpCfg->phr_Config;
6191       if(phrConfig)
6192       {
6193          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6194          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6195       }
6196
6197       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6198    }
6199
6200    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6201    if(phyCellGrpCfg)
6202    {
6203       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6204       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6205    }
6206
6207    spCellCfg = cellGrpCfg->spCellConfig;
6208    if(spCellCfg)
6209    {
6210       if(spCellCfg->servCellIndex)
6211       {
6212          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6213          {
6214             if(spCellCfg->spCellConfigDedicated)
6215             {
6216                srvCellCfg = spCellCfg->spCellConfigDedicated;
6217                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
6218                {
6219                   if(srvCellCfg->initialDownlinkBWP)
6220                   {
6221                      dlBwp = srvCellCfg->initialDownlinkBWP;
6222                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6223                      {
6224                         if(srvCellCfg->defaultDownlinkBWP_Id)
6225                         {
6226                            if(srvCellCfg->uplinkConfig)
6227                            {
6228                               if(srvCellCfg->pdsch_ServingCellConfig)
6229                               {
6230                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6231                                  if(pdschCfg->choice.setup)
6232                                  {
6233                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6234                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6235                                  }
6236                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6237                                           ServingCellConfig__pdsch_ServingCellConfig));
6238                               }
6239                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6240                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6241                            }
6242                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6243                         }
6244                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6245                      }
6246                      if(dlBwp->pdcch_Config)
6247                      {
6248                         if(dlBwp->pdsch_Config)
6249                         {
6250                            FreeBWPDlDedPdschCfg(dlBwp);
6251                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6252                         }
6253                         FreeBWPDlDedPdcchCfg(dlBwp);
6254                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6255                      }
6256                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6257                   }
6258                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
6259                }
6260                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6261             }
6262             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6263          }
6264          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
6265       }
6266       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6267    }
6268    return ROK;
6269 }
6270 /*******************************************************************
6271  *
6272  * @brief Builds DU To CU RRC Container
6273  *
6274  * @details
6275  *
6276  *    Function : BuildDuToCuRrcContainer
6277  *
6278  *    Functionality: Builds DuToCuRrcContainer
6279  *
6280  * @params[in] idx, index in F1AP msg
6281  *             DuToCuRRCContainer, DuToCuRRCContainer
6282  *
6283  * @return ROK     - success
6284  *         RFAILED - failure
6285  *
6286  * ****************************************************************/
6287 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
6288 {
6289    uint8_t  ret = ROK;
6290    CellGroupConfigRrc_t  cellGrpCfg;
6291    asn_enc_rval_t        encRetVal;
6292    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
6293    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6294
6295    while(true)
6296    {
6297       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6298
6299       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6300       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6301       if(!cellGrpCfg.rlc_BearerToAddModList)
6302       {
6303          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6304          ret = RFAILED;
6305          break;
6306       }
6307       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
6308       {
6309          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
6310          ret = RFAILED;
6311          break;
6312       }
6313
6314       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6315       cellGrpCfg.mac_CellGroupConfig = NULLP;
6316       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6317       if(!cellGrpCfg.mac_CellGroupConfig)
6318       {
6319          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6320          ret = RFAILED;
6321          break;
6322       }
6323       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6324       {
6325          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6326          ret = RFAILED;
6327          break;
6328       }
6329
6330       cellGrpCfg.physicalCellGroupConfig = NULLP;
6331       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6332       if(!cellGrpCfg.physicalCellGroupConfig)
6333       {
6334          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6335          ret = RFAILED;
6336          break;
6337       }
6338       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6339       {
6340          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6341          ret = RFAILED;
6342          break;
6343       }
6344
6345       cellGrpCfg.spCellConfig = NULLP;
6346       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6347       if(!cellGrpCfg.spCellConfig)
6348       {
6349          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6350          ret = RFAILED;
6351          break;
6352       }
6353       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6354       {
6355          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6356          ret = RFAILED;
6357          break;
6358       }
6359
6360       cellGrpCfg.sCellToAddModList = NULLP;
6361       cellGrpCfg.sCellToReleaseList = NULLP;
6362       cellGrpCfg.ext1 = NULLP;
6363
6364       /* encode cellGrpCfg into duToCuRrcContainer */
6365       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6366       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6367       encBufSize = 0;
6368       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6369       /* Encode results */
6370       if(encRetVal.encoded == ENCODE_FAIL)
6371       {
6372          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6373                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6374          ret = RFAILED;
6375          break;
6376       }
6377       else
6378       {
6379          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
6380          for(int i=0; i< encBufSize; i++)
6381          {
6382             printf("%x",encBuf[i]);
6383          }
6384       }
6385
6386       duToCuRrcContainer->size = encBufSize;
6387       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
6388       if(!duToCuRrcContainer->buf)
6389       {
6390          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6391          ret = RFAILED;
6392          break;
6393       }
6394       if(ret == ROK)
6395       {
6396          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
6397       }
6398       break;
6399    }
6400    FreeMemDuToCuRrcCont(&cellGrpCfg);
6401    return ret;
6402 }
6403
6404 /*******************************************************************
6405  *
6406  * @brief Free memory allocated in InitialULRRCMessage
6407  *
6408  * @details
6409  *
6410  *    Function : freeInitUlRrcMsgTransfer
6411  *
6412  *    Functionality: Free memory allocated in InitialULRRCMessage
6413  *
6414  * @params[in]F1AP_PDU_t  *f1apMsg)
6415  *
6416  * @return ROK     - success
6417  *         RFAILED - failure
6418  *
6419  * ****************************************************************/
6420
6421 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
6422 {
6423    uint8_t ieIdx, arrIdx;
6424    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6425
6426    if(f1apMsg)
6427    {
6428       if(f1apMsg->choice.initiatingMessage)
6429       {
6430          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6431             choice.InitialULRRCMessageTransfer;
6432          if(initULRRCMsg->protocolIEs.list.array)
6433          {
6434             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6435             {
6436                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6437                {
6438                   case ProtocolIE_ID_id_NRCGI:
6439                   {
6440                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6441                      {
6442                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6443                         {
6444                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6445                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6446                         }
6447                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6448                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6449                      }
6450                      break;
6451                   }
6452                   case ProtocolIE_ID_id_RRCContainer:
6453                   {
6454                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6455                      {
6456                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6457                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6458                      }
6459                      break;
6460                   }
6461                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6462                   {
6463                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6464                      {
6465                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6466                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6467                      }
6468                      break;
6469                   }
6470                   default:
6471                      break;
6472                }
6473              }
6474              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6475              {
6476                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6477                 {
6478                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6479                       sizeof(InitialULRRCMessageTransferIEs_t));
6480                 }
6481              }
6482              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6483           }
6484          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6485       }
6486       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6487    }
6488    else
6489    {
6490       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6491       return RFAILED;
6492    }
6493    return ROK;
6494 }
6495
6496 /*******************************************************************
6497  *
6498  * @brief Builds and sends the InitialULRRCMessage
6499  *
6500  * @details
6501  *
6502  *    Function : BuildAndSendInitialRrcMsgTransfer
6503  *
6504  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6505  *                   it to the CU through SCTP.
6506  *
6507  * @params[in]
6508  *
6509  * @return ROK     - success
6510  *         RFAILED - failure
6511  *
6512  * ****************************************************************/
6513 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6514       uint16_t rrcContSize, uint8_t *rrcContainer)
6515 {
6516    uint8_t   ret;
6517    uint8_t   elementCnt;
6518    uint8_t   ieIdx;
6519    asn_enc_rval_t  encRetVal;
6520    F1AP_PDU_t  *f1apMsg = NULLP;
6521    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6522    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6523
6524    while(true)
6525    {
6526       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6527       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6528       if(f1apMsg == NULLP)
6529       {
6530          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6531          break;
6532       }
6533       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6534       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6535       if(f1apMsg->choice.initiatingMessage == NULLP)
6536       {
6537          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6538          break;
6539       }
6540       f1apMsg->choice.initiatingMessage->procedureCode =\
6541                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6542       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6543       f1apMsg->choice.initiatingMessage->value.present = \
6544                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6545       initULRRCMsg =\
6546                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6547       elementCnt = 5;
6548       initULRRCMsg->protocolIEs.list.count = elementCnt;
6549       initULRRCMsg->protocolIEs.list.size = \
6550                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6551       /* Initialize the F1Setup members */
6552       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6553       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6554       {
6555          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6556                RRCSetupRequestMessageTransferIEs failed");
6557          break;
6558       }
6559       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6560       {
6561          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6562                sizeof(InitialULRRCMessageTransferIEs_t));
6563          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6564          {
6565             break;
6566          }
6567       }
6568       ieIdx = 0;
6569       /*GNB DU UE F1AP ID*/
6570       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6571                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6572       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6573       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6574                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6575       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6576
6577
6578       /*NRCGI*/
6579       ieIdx++;
6580       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6581                                                         ProtocolIE_ID_id_NRCGI;
6582       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6583       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6584                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6585
6586       ret =\
6587            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6588       if(ret!=ROK)
6589       {
6590          break;
6591       }
6592
6593       /*CRNTI*/
6594       ieIdx++;
6595       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6596                                                         ProtocolIE_ID_id_C_RNTI;
6597       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6598       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6599                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6600       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6601
6602       /*RRCContainer*/
6603       ieIdx++;
6604       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6605                                                         ProtocolIE_ID_id_RRCContainer;
6606       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6607       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6608                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6609
6610       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6611       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6612             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6613       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6614       {
6615          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6616          break;
6617
6618       }
6619       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6620             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6621
6622
6623       /*DUtoCURRCContainer*/
6624       ieIdx++;
6625       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6626       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6627       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6628                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6629
6630       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6631       if(ret != ROK)
6632       {
6633          break;
6634       }
6635
6636       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6637
6638       /* Encode the F1SetupRequest type as APER */
6639       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6640       encBufSize = 0;
6641       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6642       /* Encode results */
6643       if(encRetVal.encoded == ENCODE_FAIL)
6644       {
6645          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6646                structure (at %s)\n",encRetVal.failed_type ? \
6647                encRetVal.failed_type->name : "unknown");
6648          ret = RFAILED;
6649          break;
6650       }
6651       else
6652       {
6653
6654          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6655                Message transfer\n");
6656          for(int i=0; i< encBufSize; i++)
6657          {
6658             printf("%x",encBuf[i]);
6659          }
6660       }
6661       /* Sending  msg  */
6662       if(sendF1APMsg() != ROK)
6663       {
6664          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6665          ret = RFAILED;
6666          break;
6667       }
6668       break;
6669    }
6670    freeInitUlRrcMsgTransfer(f1apMsg);
6671    return ret;
6672 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6673
6674 /*****  UE SETUP REQUEST *****/
6675
6676 /*******************************************************************
6677  *
6678  * @brief Free Qos And Snssai Drb Info
6679  *
6680  * @details
6681  *
6682  *    Function : freeDrbQosAndSnssaiInfo
6683  *
6684  *    Functionality: Free Qos And Snssai Drb Info
6685  *
6686  * @params[in] LcCfg *lcCfg,
6687  * @return void
6688  *
6689  * ****************************************************************/
6690 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6691 {
6692    if(lcCfg->snssai)
6693    {
6694       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6695    }
6696    if(lcCfg->drbQos)
6697    {
6698       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6699    }
6700 }
6701
6702 /******************************************************************
6703 *
6704 * @brief Function to delete the RLC Lc cfg from UE APP DB
6705 *
6706 * @details
6707 *
6708 *  Function : freeRlcLcCfg
6709 *
6710 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6711 *
6712 *
6713  *****************************************************************/
6714
6715 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6716 {
6717    switch(lcCfg->rlcMode)
6718    {
6719       case RLC_AM :
6720          {
6721             if(lcCfg->u.amCfg)
6722             {
6723                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6724             }
6725             break;
6726          }
6727       case RLC_UM_BI_DIRECTIONAL :
6728          {
6729             if(lcCfg->u.umBiDirCfg)
6730             {
6731                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6732             }
6733             break;
6734          }
6735       case RLC_UM_UNI_DIRECTIONAL_UL :
6736          {
6737             if(lcCfg->u.umUniDirUlCfg)
6738             {
6739                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6740             }
6741             break;
6742
6743          }
6744       case RLC_UM_UNI_DIRECTIONAL_DL :
6745          {
6746             if(lcCfg->u.umUniDirDlCfg)
6747             {
6748                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6749             }
6750             break;
6751          }
6752       default:
6753          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6754          break;
6755    }
6756    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6757 }
6758
6759 /*******************************************************************
6760  *
6761  * @brief Function to free MacLcCfg
6762  *
6763  * @details
6764  *
6765  *    Function : freeMacLcCfg
6766  *
6767  *    Functionality: Function to free MacLcCfg
6768  *
6769  * @params[in] LcCfg *lcCfg,
6770  * @return void
6771  *
6772  * ****************************************************************/
6773
6774 void  freeMacLcCfg(LcCfg *lcCfg)
6775 {
6776     /* Deleting DRBQOS */
6777    if(lcCfg->drbQos)
6778    {
6779       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6780    }
6781    /* Deleting SNSSAI */
6782    if(lcCfg->snssai)
6783    {
6784       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6785    }
6786 }
6787 /*******************************************************************
6788  *
6789  * @brief Free UE NR Capability received in UE Context setup request
6790  *
6791  * @details
6792  *
6793  *    Function : freeAperDecodeUeNrCapability
6794  *
6795  *    Functionality:
6796  *       Free UE NR Capability received in UE Context setup request
6797  *
6798  * @params[in]
6799  * @return ROK     - success
6800  *         RFAILED - failure
6801  *
6802  * ****************************************************************/
6803 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6804 {
6805    uint8_t arrIdx =0;
6806    FeatureSets_t *featureSets =NULLP;
6807    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6808
6809    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6810    {
6811       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6812       {
6813          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6814             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6815       }
6816       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6817    }
6818
6819    if(ueNrCap->featureSets)
6820    {
6821       featureSets = ueNrCap->featureSets;
6822       if(featureSets->featureSetsDownlinkPerCC)
6823       {
6824          if(featureSets->featureSetsDownlinkPerCC->list.array)
6825          {
6826             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6827             {
6828                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6829                {
6830                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6831                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6832                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6833                }
6834             }
6835             free(featureSets->featureSetsDownlinkPerCC->list.array);
6836          }
6837          free(featureSets->featureSetsDownlinkPerCC);
6838       }
6839       if(featureSets->featureSetsUplinkPerCC)
6840       {
6841          if(featureSets->featureSetsUplinkPerCC->list.array)
6842          {
6843             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6844             {
6845                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6846                {
6847                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6848                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6849                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6850                }
6851             }
6852             free(featureSets->featureSetsUplinkPerCC->list.array);
6853          }
6854          free(featureSets->featureSetsUplinkPerCC);
6855       }
6856       free(ueNrCap->featureSets);
6857    }
6858 }
6859
6860 /*******************************************************************
6861 *
6862 * @brief Function to free PdcchSearchSpcToAddModList
6863          where memory allocated by aper_decoder
6864 *
6865 * @details
6866 *
6867 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6868 *
6869 *    Functionality: Function to free PdcchSearchSpcToAddModList
6870 *
6871 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6872 * @return void
6873 *
6874 * ****************************************************************/
6875
6876 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6877 {
6878    uint8_t searchSpcArrIdx=0;
6879    uint8_t searchSpcArrIdx1=0;
6880    struct  SearchSpace *searchSpc=NULLP;
6881
6882
6883    if(searchSpcList->list.array)
6884    {
6885       if(searchSpcList->list.array[searchSpcArrIdx1])
6886       {
6887          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6888          if(searchSpc->controlResourceSetId)
6889          {
6890             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6891             {
6892                if(searchSpc->monitoringSymbolsWithinSlot)
6893                {
6894                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6895                   {
6896                      if(searchSpc->nrofCandidates)
6897                      {
6898                         if(searchSpc->searchSpaceType)
6899                         {
6900                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6901                            free(searchSpc->searchSpaceType);
6902                         }
6903                         free(searchSpc->nrofCandidates);
6904                      }
6905                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6906                   }
6907                   free(searchSpc->monitoringSymbolsWithinSlot);
6908                }
6909                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6910             }
6911             free(searchSpc->controlResourceSetId);
6912          }
6913       }
6914       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6915       {
6916          free(searchSpcList->list.array[searchSpcArrIdx]);
6917       }
6918       free(searchSpcList->list.array);
6919    }
6920 }
6921 /*******************************************************************
6922 *
6923 * @brief Function for free part for the memory allocated by aper_decoder
6924 *
6925 * @details
6926 *
6927 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6928 *
6929 *    Functionality: Function to free BWPDlDedPdcchConfig
6930 *
6931 * @params[in]
6932 * @return void
6933 *
6934 * ****************************************************************/
6935
6936
6937 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6938 {
6939    uint8_t arrIdx1=0;
6940    uint8_t arrIdx2=0;
6941    struct PDCCH_Config *pdcchCfg=NULLP;
6942    struct ControlResourceSet *controlRSet=NULLP;
6943    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6944
6945    if(dlBwp->pdcch_Config->choice.setup)
6946    {
6947       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6948       if(pdcchCfg->controlResourceSetToAddModList)
6949       {
6950          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6951          if(controlRSetList->list.array)
6952          {
6953             controlRSet = controlRSetList->list.array[arrIdx2];
6954             if(controlRSet)
6955             {
6956                if(controlRSet->frequencyDomainResources.buf)
6957                {
6958                   if(controlRSet->pdcch_DMRS_ScramblingID)
6959                   {
6960                      if(pdcchCfg->searchSpacesToAddModList)
6961                      {
6962                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6963                         free(pdcchCfg->searchSpacesToAddModList);
6964                      }
6965                      free(controlRSet->pdcch_DMRS_ScramblingID);
6966                   }
6967                   free(controlRSet->frequencyDomainResources.buf);
6968                }
6969             }
6970             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6971             {
6972                free(controlRSetList->list.array[arrIdx1]);
6973             }
6974             free(controlRSetList->list.array);
6975          }
6976          free(pdcchCfg->controlResourceSetToAddModList);
6977       }
6978       free(dlBwp->pdcch_Config->choice.setup);
6979    }
6980 }
6981 /*******************************************************************
6982 *
6983 * @brief Function to free PdschTimeDomAllocationList
6984 *     where the memory allocated by aper_decoder
6985 *
6986 * @details
6987 *
6988 *    Function : freeAperDecodePdschTimeDomAllocationList
6989 *
6990 *    Functionality: Function to free PdschTimeDomAllocationList
6991 *
6992 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6993 * @return void
6994 *
6995 * ****************************************************************/
6996
6997
6998 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6999 {
7000    uint8_t arrIdx=0;
7001
7002    if(timeDomAllocList->choice.setup)
7003    {
7004       if(timeDomAllocList->choice.setup->list.array)
7005       {
7006          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
7007          {
7008             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
7009          }
7010          free(timeDomAllocList->choice.setup->list.array);
7011       }
7012       free(timeDomAllocList->choice.setup);
7013    }
7014 }
7015
7016 /*******************************************************************
7017 *
7018 * @brief Function to free BWPDlDedPdschConfig
7019 *        where the memory allocated by aper_decoder
7020 *
7021 * @details
7022 *
7023 *    Function : freeAperDecodeBWPDlDedPdschConfig
7024 *
7025 *    Functionality: Function to free BWPDlDedPdschConfig
7026 *
7027 * @params[in] BWP_DownlinkDedicated_t *dlBwp
7028 * @return void
7029 *
7030 * ****************************************************************/
7031
7032
7033 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
7034 {
7035    struct PDSCH_Config *pdschCfg=NULLP;
7036    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
7037    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
7038    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
7039
7040    if(dlBwp->pdsch_Config->choice.setup)
7041    {
7042       pdschCfg=dlBwp->pdsch_Config->choice.setup;
7043       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7044       {
7045          if(pdschCfg->pdsch_TimeDomainAllocationList)
7046          {
7047             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
7048             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
7049             {
7050                prbBndlType=&pdschCfg->prb_BundlingType;
7051                free(prbBndlType->choice.staticBundling);
7052                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
7053             }
7054             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
7055             free(pdschCfg->pdsch_TimeDomainAllocationList);
7056          }
7057          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
7058          if(dmrsDlCfg->choice.setup)
7059          {
7060             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
7061             free(dmrsDlCfg->choice.setup);
7062          }
7063          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
7064       }
7065       free(dlBwp->pdsch_Config->choice.setup);
7066    }
7067 }
7068 /*******************************************************************
7069 *
7070 * @brief Function to free PuschTimeDomAllocListCfg
7071                  where the memory allocated by aper_decoder
7072 *
7073 * @details
7074 *
7075 *    Function : freeAperDecodePuschTimeDomAllocListCfg
7076 *
7077 *    Functionality: Function to free PuschTimeDomAllocListCfg
7078 *
7079 * @params[in] PUSCH_Config_t *puschCfg
7080 * @return void
7081 *
7082 * ****************************************************************/
7083
7084
7085 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
7086 {
7087    uint8_t arrIdx=0;
7088    uint8_t arrIdx1=0;
7089    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7090
7091    if(puschCfg->pusch_TimeDomainAllocationList)
7092    {
7093       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7094       if(timeDomAllocList_t->choice.setup)
7095       {
7096          if(timeDomAllocList_t->choice.setup->list.array)
7097          {
7098             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
7099             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
7100             {
7101                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
7102             }
7103             free(timeDomAllocList_t->choice.setup->list.array);
7104          }
7105          free(timeDomAllocList_t->choice.setup);
7106       }
7107       free(puschCfg->transformPrecoder);
7108       free(puschCfg->pusch_TimeDomainAllocationList);
7109    }
7110 }
7111 /*******************************************************************
7112 *
7113 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
7114 *
7115 * @details
7116 *
7117 *    Function : freeAperDecodeInitialUlBWPConfig
7118 *
7119 *    Functionality: Function to free InitialUlBWPConfig
7120 *
7121 * @params[in]  BWP_UplinkDedicated_t *ulBwp
7122 * @return void
7123 *
7124 * ****************************************************************/
7125
7126
7127 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
7128 {
7129    uint8_t  rSetIdx =0;
7130    uint8_t  rsrcIdx =0;
7131    SRS_Config_t   *srsCfg = NULLP;
7132    PUSCH_Config_t *puschCfg = NULLP;
7133    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
7134    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
7135    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
7136    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
7137
7138    if(ulBwp->pusch_Config)
7139    {
7140       if(ulBwp->pusch_Config->choice.setup)
7141       {
7142          puschCfg=ulBwp->pusch_Config->choice.setup;
7143          if(puschCfg->dataScramblingIdentityPUSCH)
7144          {
7145             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
7146             {
7147                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
7148                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
7149                if(dmrsUlCfg->choice.setup)
7150                {
7151                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
7152                   {
7153                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
7154                      {
7155                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
7156                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
7157                      }
7158                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
7159                   }
7160                   free(dmrsUlCfg->choice.setup);
7161                }
7162                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
7163             }
7164             free(puschCfg->dataScramblingIdentityPUSCH);
7165          }
7166          free(ulBwp->pusch_Config->choice.setup);
7167       }
7168       free(ulBwp->pusch_Config);
7169
7170       /* Free SRS-Config */
7171       if(ulBwp->srs_Config)
7172       {
7173          if(ulBwp->srs_Config->choice.setup)
7174          {
7175             srsCfg = ulBwp->srs_Config->choice.setup;
7176
7177             /* Free Resource Set to add/mod list */
7178             if(srsCfg->srs_ResourceSetToAddModList)
7179             {
7180                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
7181                if(rsrcSetList->list.array)
7182                {
7183                   rSetIdx = 0;
7184
7185                   /* Free SRS resource Id list in this SRS resource set */
7186                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
7187                   {
7188                      rsrcIdList =
7189                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
7190
7191                      if(rsrcIdList->list.array)
7192                      {
7193                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
7194                               rsrcIdx++)
7195                         {
7196                            free(rsrcIdList->list.array[rsrcIdx]);
7197                         }
7198                         free(rsrcIdList->list.array);
7199                      }
7200                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
7201                   }
7202
7203                   /* Free resource type info for this SRS resource set */
7204
7205                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
7206
7207                   /* Free memory for each resource set */
7208                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
7209                   {
7210                      free(rsrcSetList->list.array[rSetIdx]);
7211                   }
7212                   free(rsrcSetList->list.array);
7213                }
7214                free(srsCfg->srs_ResourceSetToAddModList);
7215             }
7216
7217             /* Free resource to add/modd list */
7218             if(srsCfg->srs_ResourceToAddModList)
7219             {
7220                resourceList = srsCfg->srs_ResourceToAddModList;
7221                if(resourceList->list.array)
7222                {
7223                   rsrcIdx = 0;
7224
7225                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
7226                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
7227
7228                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
7229                   {
7230                      free(resourceList->list.array[rsrcIdx]);
7231                   }
7232                   free(resourceList->list.array);
7233                }
7234                free(srsCfg->srs_ResourceToAddModList);
7235             }
7236
7237             free(ulBwp->srs_Config->choice.setup);
7238          }
7239          free(ulBwp->srs_Config);
7240       }
7241    }
7242 }
7243 /*******************************************************************
7244 *
7245 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
7246 *
7247 * @details
7248 *
7249 *    Function : freeAperDecodeinitialUplinkBWPConfig
7250 *
7251 *    Functionality: Function to free initialUplinkBWPConfig
7252 *
7253 * @params[in] UplinkConfig_t *ulCfg
7254 * @return void
7255 *
7256 * ****************************************************************/
7257
7258
7259 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
7260 {
7261    BWP_UplinkDedicated_t *ulBwp=NULLP;
7262    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
7263
7264    if(ulCfg->initialUplinkBWP)
7265    {
7266       ulBwp=ulCfg->initialUplinkBWP;
7267       if(ulCfg->firstActiveUplinkBWP_Id)
7268       {
7269          if(ulCfg->pusch_ServingCellConfig)
7270          {
7271             puschCfg=ulCfg->pusch_ServingCellConfig;
7272             if(puschCfg->choice.setup)
7273             {
7274                if(puschCfg->choice.setup->ext1)
7275                {
7276                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
7277                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
7278                   free(puschCfg->choice.setup->ext1);
7279                }
7280                free(puschCfg->choice.setup);
7281             }
7282             free(ulCfg->pusch_ServingCellConfig);
7283          }
7284          free(ulCfg->firstActiveUplinkBWP_Id);
7285       }
7286       freeAperDecodeInitialUlBWPConfig(ulBwp);
7287       free(ulCfg->initialUplinkBWP);
7288    }
7289 }
7290
7291 /*******************************************************************
7292  *
7293  * @brief Function to free DuUeCfg
7294  *
7295  * @details
7296  *
7297  *    Function : freeDuUeCfg
7298  *
7299  *    Functionality: Function to free DuUeCfg
7300  *
7301  * @params[in] DuUeCfg *ueCfg
7302  * @return void
7303  *
7304  * ****************************************************************/
7305 void freeDuUeCfg(DuUeCfg *ueCfg)
7306 {
7307    uint8_t lcIdx = 0;
7308    uint8_t arrIdx = 0;
7309    SpCellConfig_t *spCellCfg = NULLP;
7310    ServingCellConfig_t *srvCellCfg = NULLP;
7311    BWP_DownlinkDedicated_t *dlBwp = NULLP;
7312    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
7313    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
7314    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
7315    struct RLC_Config *rlcConfig = NULLP;
7316    struct LogicalChannelConfig *macLcConfig = NULLP;
7317    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
7318    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
7319    struct TAG_Config *tagConfig = NULLP;
7320    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
7321    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
7322    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
7323    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
7324
7325    if(ueCfg->ueNrCapability)
7326    {
7327       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
7328       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
7329       ueCfg->ueNrCapability = NULLP;
7330    }
7331
7332    if(ueCfg->cellGrpCfg)
7333    {
7334
7335       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
7336       if(rlcBearerList)
7337       {
7338          if(rlcBearerList->list.array)
7339          {
7340             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
7341             {
7342                if(rlcBearerList->list.array[arrIdx])
7343                {
7344                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
7345                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
7346
7347                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
7348                   {
7349                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
7350                   }
7351                   if(rlcConfig)
7352                   {
7353                      if(rlcConfig->choice.am)
7354                      {
7355                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
7356                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
7357                         free(rlcConfig->choice.am);
7358                      }
7359                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
7360                   }
7361                   if(macLcConfig)
7362                   {
7363                      if(macLcConfig->ul_SpecificParameters)
7364                      {
7365                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
7366                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
7367                         free(macLcConfig->ul_SpecificParameters);
7368                      }
7369                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
7370                   }
7371                   free(rlcBearerList->list.array[arrIdx]);
7372                }
7373             }
7374             free(rlcBearerList->list.array);
7375          }
7376          free(cellGrpCfg->rlc_BearerToAddModList);
7377       }
7378
7379       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
7380       if(macCellGrpCfg)
7381       {
7382          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
7383          if(schedulingRequestConfig)
7384          {
7385             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
7386             if(schReqList)
7387             {
7388                if(schReqList->list.array)
7389                {
7390                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
7391                   {
7392                      if(schReqList->list.array[arrIdx])
7393                      {
7394                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
7395                         free(schReqList->list.array[arrIdx]);
7396                      }
7397                   }
7398                   free(schReqList->list.array);
7399                }
7400                free(schedulingRequestConfig->schedulingRequestToAddModList);
7401             }
7402             free(macCellGrpCfg->schedulingRequestConfig);
7403          }
7404          if(macCellGrpCfg->bsr_Config)
7405          {
7406             free(macCellGrpCfg->bsr_Config);
7407          }
7408          tagConfig = macCellGrpCfg->tag_Config;
7409          if(tagConfig)
7410          {
7411             tagList = tagConfig->tag_ToAddModList;
7412             if(tagList)
7413             {
7414                if(tagList->list.array)
7415                {
7416                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
7417                   {
7418                      free(tagList->list.array[arrIdx]);
7419                   }
7420                   free(tagList->list.array);
7421                }
7422                free(tagConfig->tag_ToAddModList);
7423             }
7424             free(tagConfig);
7425          }
7426
7427          phrConfig = macCellGrpCfg->phr_Config;
7428          if(phrConfig)
7429          {
7430             free(phrConfig->choice.setup);
7431             free(phrConfig);
7432          }
7433
7434          free(macCellGrpCfg);
7435       }
7436
7437       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7438       if(phyCellGrpCfg)
7439       {
7440          free(phyCellGrpCfg->p_NR_FR1);
7441          free(phyCellGrpCfg);
7442       }
7443
7444       spCellCfg = cellGrpCfg->spCellConfig;
7445       if(spCellCfg)
7446       {
7447          if(spCellCfg->servCellIndex)
7448          {
7449             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7450             {
7451                if(spCellCfg->spCellConfigDedicated)
7452                {
7453                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7454                   if(srvCellCfg->initialDownlinkBWP)
7455                   {
7456                      dlBwp = srvCellCfg->initialDownlinkBWP;
7457                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7458                      {
7459                         if(srvCellCfg->defaultDownlinkBWP_Id)
7460                         {
7461                            if(srvCellCfg->uplinkConfig)
7462                            {
7463
7464                               if(srvCellCfg->pdsch_ServingCellConfig)
7465                               {
7466                                  pdschCfg=
7467                                     srvCellCfg->pdsch_ServingCellConfig;
7468                                  if(pdschCfg->choice.setup)
7469                                  {
7470
7471                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7472                                     free(pdschCfg->choice.setup);
7473                                  }
7474
7475                                  free(srvCellCfg->pdsch_ServingCellConfig);
7476                               }
7477
7478                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7479                               free(srvCellCfg->uplinkConfig);
7480                            }
7481                            free(srvCellCfg->defaultDownlinkBWP_Id);
7482                         }
7483
7484                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7485                      }
7486                      if(dlBwp->pdcch_Config)
7487                      {
7488                         if(dlBwp->pdsch_Config)
7489                         {
7490                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7491                            free(dlBwp->pdsch_Config);
7492                         }
7493                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7494                         free(dlBwp->pdcch_Config);
7495                      }
7496                      free(srvCellCfg->initialDownlinkBWP);
7497                   }
7498
7499                   free(spCellCfg->spCellConfigDedicated);
7500                }
7501                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7502             }
7503             free(spCellCfg->servCellIndex);
7504          }
7505          free(spCellCfg);
7506       }
7507       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7508       ueCfg->cellGrpCfg = NULLP;
7509    }
7510    if(ueCfg->ambrCfg)
7511    {
7512       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7513    }
7514    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7515    {
7516       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7517    }
7518    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7519    {
7520       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7521    }
7522    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7523    {
7524       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7525    }
7526 }
7527
7528 /*******************************************************************
7529  *
7530  * @brief Function to free UecontextSetupDb
7531  *
7532  * @details
7533  *
7534  *    Function : freeF1UeDb
7535  *
7536  *    Functionality: Function to free UecontextSetupDb
7537  *
7538  * @params[in] UecontextSetupDb *
7539  * @return void
7540  *
7541  * ****************************************************************/
7542
7543 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7544 {
7545
7546    if(f1UeDb->dlRrcMsg)
7547    {
7548       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7549       {
7550         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7551                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7552       }
7553       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7554    }
7555    freeDuUeCfg(&f1UeDb->duUeCfg);
7556    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7557    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7558 }
7559
7560 /*******************************************************************
7561  *
7562  * @brief Function to build Am cfg Info
7563  *
7564  * @details
7565  *
7566  *    Function : extractRlcAmCfg
7567  *
7568  *    Functionality: Function to build Am cfg Info
7569  *
7570  * @params[in] AmBearerCfg *
7571  *             void *
7572  *
7573  * @return ROK/RFAILED
7574  *
7575  * ****************************************************************/
7576
7577 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7578 {
7579    if(rlcAmCfg)
7580    {
7581       /* UL AM */
7582       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7583       {
7584          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7585          /*TODO: Check the timer value when sent by real CU */
7586          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7587          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7588       }
7589
7590       /* DL AM */
7591       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7592       {
7593          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7594          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7595          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7596          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7597          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7598       }
7599    }
7600 }
7601
7602 /*******************************************************************
7603  *
7604  * @brief Function to build Um Bi Info
7605  *
7606  * @details
7607  *
7608  *    Function : extractRlcUmBiCfg
7609  *
7610  *    Functionality: Function to build Um Bi Info
7611  *
7612  * @params[in] UmBiDirBearerCfg *
7613  *             void *
7614  *
7615  * @return ROK/RFAILED
7616  *
7617  * ****************************************************************/
7618
7619 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7620 {
7621    if(rlcBiCfg)
7622    {
7623       /* UL UM BI DIR Cfg */
7624       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7625       {
7626          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7627          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7628       }
7629
7630       /* DL UM BI DIR Cfg */
7631       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7632          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7633    }
7634 }
7635
7636 /*******************************************************************
7637  *
7638  * @brief Function to build Um Ul Info
7639  *
7640  * @details
7641  *
7642  *    Function : extractRlcUmUlCfg
7643  *
7644  *    Functionality: Function to build Um Ul Info
7645  *
7646  * @params[in] UmUniDirUlBearerCfg *
7647  *             void *
7648  *
7649  * @return ROK/RFAILED
7650  *
7651  * ****************************************************************/
7652
7653 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7654 {
7655    if(umUlCfg)
7656    {
7657       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7658       {
7659          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7660          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7661       }
7662    }
7663 }
7664
7665 /*******************************************************************
7666  *
7667  * @brief Function to build Um Uni Dl Info
7668  *
7669  * @details
7670  *
7671  *    Function : extractRlcUmDlCfg
7672  *
7673  *    Functionality: Function to build Um Uni Dl Info
7674  *
7675  * @params[in] UmUniDirDlBearerCfg *
7676  *             void *
7677  *
7678  * @return ROK/RFAILED
7679  *
7680  * ****************************************************************/
7681 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7682 {
7683    if(umDlCfg)
7684    {
7685       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7686          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7687    }
7688 }
7689
7690 /*******************************************************************
7691  *
7692  * @brief Function to extractRlcModeCfg
7693  *
7694  * @details
7695  *
7696  *    Function : extractRlcModeCfg
7697  *
7698  *    Functionality: Function to extractRlcModeCfg
7699  *
7700  * @params[in] RLC_Config_t *
7701  *             RlcBearerCfg *
7702  *             void  *
7703  * @return ROK/RFAILED
7704  *
7705  * ****************************************************************/
7706 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7707 {
7708    if(lcCfg)
7709    {
7710       switch(rlcMode)
7711       {
7712          case RLC_AM :
7713             {
7714                if(lcCfg->choice.am)
7715                {
7716                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7717                   if(rlcDbCfg->u.amCfg)
7718                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7719                }
7720                break;
7721             }
7722          case RLC_UM_BI_DIRECTIONAL :
7723             {
7724                if(lcCfg->choice.um_Bi_Directional)
7725                {
7726                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7727                   if(rlcDbCfg->u.umBiDirCfg)
7728                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7729                }
7730                break;
7731             }
7732          case RLC_UM_UNI_DIRECTIONAL_UL :
7733             {
7734                if(lcCfg->choice.um_Uni_Directional_DL)
7735                {
7736                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7737                   if(rlcDbCfg->u.umUniDirUlCfg)
7738                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7739                }
7740                break;
7741             }
7742          case RLC_UM_UNI_DIRECTIONAL_DL :
7743             {
7744                if(lcCfg->choice.um_Uni_Directional_UL)
7745                {
7746                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7747                   if(rlcDbCfg->u.umUniDirDlCfg)
7748                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7749                }
7750                break;
7751             }
7752          default:
7753             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7754             break;
7755       }
7756    }
7757 }
7758
7759 /*******************************************************************
7760  *
7761  * @brief Function to extract extractUlLcCfg
7762  *
7763  * @details
7764  *
7765  *    Function : extractUlLcCfg
7766  *
7767  *    Functionality: Function to extract extractUlLcCfg
7768  *
7769  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7770  * @return void
7771  *
7772  * ****************************************************************/
7773
7774 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7775 {
7776    if(ulLcCfg)
7777    {
7778       if(ulLcCfg->ul_SpecificParameters)
7779       {
7780          f1UlLcCfg->priority = \
7781             ulLcCfg->ul_SpecificParameters->priority;
7782       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7783       {
7784          f1UlLcCfg->lcGroup = \
7785            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7786       }
7787       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7788       {
7789          f1UlLcCfg->schReqId = \
7790            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7791       }
7792       f1UlLcCfg->pbr = \
7793          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7794       f1UlLcCfg->bsd = \
7795          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7796       }
7797    }
7798 }
7799
7800 /*******************************************************************
7801 *
7802 * @brief Function to extract Snssai Cfg Info from CU
7803 *
7804 * @details
7805 *
7806 *    Function : extractDrbSnssaiCfg
7807 *
7808 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
7809 *
7810 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
7811 * @return ROK/RFAILED
7812 *
7813 * ****************************************************************/
7814
7815 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
7816 {
7817    if(!(*snssaiToBeShared))
7818    {
7819       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
7820       if(snssaiToBeShared == NULLP)
7821       {
7822          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
7823          return RFAILED;
7824       }
7825    }
7826    if(RecvSnssai)
7827    {
7828       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
7829       if(RecvSnssai->sD)
7830       {
7831          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
7832       }
7833       else
7834       {
7835          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
7836          return RFAILED;
7837       }
7838    }
7839    return ROK;
7840 }
7841
7842 /*******************************************************************
7843  *
7844  * @brief Function to procRlcLcCfg
7845  *
7846  * @details
7847  *
7848  *    Function : procRlcLcCfg
7849  *
7850  *    Functionality: Function to procRlcLcCfg
7851  *
7852  * @params[in] rbId, lcId, rbType, rlcMod
7853  *             RLC_Config_t *, RlcBearerCfg * ,
7854  * @return void
7855  *
7856  * ****************************************************************/
7857
7858 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7859    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
7860 {
7861    DRB_Information_t *drbInfo;
7862
7863    lcCfg->rbId   = rbId;
7864    lcCfg->configType = configType;
7865
7866    if(rbType == RB_TYPE_SRB)
7867    {
7868       lcCfg->rbType = RB_TYPE_SRB;
7869       lcCfg->lcId   = rbId;
7870       lcCfg->lcType = LCH_DCCH;
7871       lcCfg->rlcMode = RLC_AM;
7872    }
7873    else if(rbType == RB_TYPE_DRB)
7874    {
7875       lcCfg->rbType = RB_TYPE_DRB;
7876       lcCfg->lcId   = lcId;
7877       lcCfg->lcType = LCH_DTCH;
7878       lcCfg->rlcMode = rlcMode;
7879    }
7880    if(f1RlcCfg) /* rlc mode config recived */
7881    {
7882       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7883    }
7884    if(qoSInformation != NULLP)
7885    {
7886       if(qoSInformation->present == QoSInformation_PR_choice_extension)
7887       {
7888          if(qoSInformation->choice.choice_extension->value.present ==\
7889                QoSInformation_ExtIEs__value_PR_DRB_Information)
7890          {
7891             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7892             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
7893             {
7894                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
7895                return RFAILED;
7896             }
7897          }
7898       }
7899    }
7900 }
7901
7902 /*******************************************************************
7903  *
7904  * @brief Fills DrbQos Info received by CU
7905  *
7906  * @details
7907  *
7908  *    Function : extractQosInfo
7909  *
7910  *    Functionality: Fills DrbQos Info received  by CU
7911  *
7912  * @params[in] DrbQosInfo *qosToAdd,
7913  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7914  * @return void
7915  *
7916  * ****************************************************************/
7917
7918 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7919 {
7920    uint8_t qosCntIdx = 0;
7921    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
7922
7923    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7924    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7925                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7926    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7927    {
7928       qosToAdd->u.nonDyn5Qi.avgWindow = \
7929                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7930    }
7931    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7932                                            *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7933    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7934    {
7935       qosToAdd->u.nonDyn5Qi.priorLevel = \
7936                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7937    }
7938    qosToAdd->ngRanRetPri.priorityLevel = \
7939                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7940    qosToAdd->ngRanRetPri.preEmptionCap = \
7941                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7942    qosToAdd->ngRanRetPri.preEmptionVul = \
7943                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7944    if(qosFlowCfg->gBR_QoS_Flow_Information)
7945    {
7946       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7947             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7948             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7949       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7950             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7951             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7952       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7953             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7954             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7955       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7956             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7957             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7958    }
7959    /*Extracting PDU_SESSION_ID*/
7960    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
7961    if(qosIeExt)
7962    {
7963       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
7964       {
7965          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
7966                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
7967          {
7968             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
7969             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
7970          }
7971       }
7972    }
7973    qosToAdd->ulPduSessAggMaxBitRate = 0;
7974 }
7975
7976 /*******************************************************************
7977  *
7978  * @brief Function to extract GTP Tunnel Info from CU
7979  *
7980  * @details
7981  *
7982  *    Function : extractUpTnlInfo
7983  *
7984  *    Functionality: Function to extract GTP Tunnel Info from CU
7985  *
7986  * @params[in] F1AP message
7987  * @return ROK/RFAILED
7988  *
7989  * ****************************************************************/
7990
7991 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7992    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7993 {
7994    uint8_t tnlIdx;
7995    uint32_t ipv4_du = 0;
7996    GTPTunnel_t *gtpTunnel = NULLP;
7997
7998    upTnlInfo->drbId = drbId;
7999    upTnlInfo->configType = configType;
8000 #ifdef O1_ENABLE
8001    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
8002 #else
8003    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
8004 #endif
8005
8006    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
8007    {
8008       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
8009       {
8010          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
8011          {
8012             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
8013             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
8014             if(upTnlInfo->tnlCfg1 == NULLP)
8015             {
8016                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
8017                return RFAILED;
8018             }
8019             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
8020             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
8021             if(gtpTunnel->gTP_TEID.size > 0)
8022             {
8023                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
8024             }
8025          }
8026          break;
8027       }
8028    }
8029    return ROK;
8030 }
8031
8032 /*******************************************************************
8033 *
8034 * @brief Function to extract Drb Qos Cfg Info from CU
8035 *
8036 * @details
8037 *
8038 *    Function : extractDrbQosCfg
8039 *
8040 *    Functionality: Function to extract Drb Qos Cfg Info from CU
8041 *
8042 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
8043 * @return ROK/RFAILED
8044 *
8045 * ****************************************************************/
8046
8047 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
8048 {
8049    if(!macLcToAdd->drbQos)
8050    {
8051       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
8052       if(macLcToAdd->drbQos == NULLP)
8053       {
8054          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
8055          return RFAILED;
8056       }
8057
8058    }
8059    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
8060    {
8061       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
8062       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
8063    }
8064    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
8065    {
8066       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
8067       return RFAILED;
8068    }
8069    return ROK;
8070 }
8071 /*******************************************************************
8072  *
8073  * @brief Function to extract DRB info received from CU
8074  *
8075  * @details
8076  *
8077  *    Function : extractDrbCfg
8078  *
8079  *    Functionality: Function to extract DRB info received from CU
8080  *
8081  * @params[in] F1AP message
8082  * @return void
8083  *
8084  * ****************************************************************/
8085 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
8086 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
8087 {
8088    DRB_Information_t *drbInfo = NULLP;
8089
8090    if(drbItem != NULLP)
8091    {
8092       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
8093       {
8094          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
8095          return RFAILED;
8096       }
8097       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
8098       {
8099          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
8100          {
8101             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
8102             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
8103             {
8104                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
8105                return RFAILED;
8106             }
8107          }
8108       }
8109    }
8110    else if(drbSetupModItem != NULLP)
8111    {
8112       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
8113       upTnlInfo) != ROK)
8114       {
8115          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
8116          return RFAILED;
8117       }
8118       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
8119       {
8120          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
8121          QoSInformation_ExtIEs__value_PR_DRB_Information)
8122          {
8123             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
8124             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
8125             {
8126                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
8127                return RFAILED;
8128             }
8129
8130          }
8131       }
8132    }
8133    else if(drbModItem != NULLP)
8134    {
8135       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
8136       upTnlInfo) != ROK)
8137       {
8138          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
8139          return RFAILED;
8140       }
8141       if(drbModItem->qoSInformation != NULLP)
8142       {
8143          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
8144          {
8145             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
8146                   QoSInformation_ExtIEs__value_PR_DRB_Information)
8147             {
8148                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
8149                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
8150                {
8151                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
8152                   return RFAILED;
8153                }
8154
8155             }
8156          }
8157       }
8158    }
8159    return ROK;
8160 }
8161
8162 /*******************************************************************
8163  *
8164  * @brief Function to extract RB info received from CU
8165  *
8166  * @details
8167  *
8168  *    Function : extractMacRbCfg
8169  *
8170  *    Functionality: Function to extract RB info received from CU
8171  *
8172  * @params[in] F1AP message
8173  * @return ROK/RFAILED
8174  *
8175  * ****************************************************************/
8176
8177 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
8178 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
8179 {
8180    if(drbCfg != NULLP)
8181    {
8182       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
8183       {
8184          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
8185          return RFAILED;
8186       }
8187    }
8188    else if(drbSetupModCfg != NULLP)
8189    {
8190       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
8191       {
8192          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
8193          return RFAILED;
8194       }
8195    }
8196    else if(drbModCfg != NULLP)
8197    {
8198       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
8199       {
8200          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
8201          return RFAILED;
8202       }
8203    }
8204    else
8205    {
8206       lcCfg->drbQos = NULLP;
8207       lcCfg->snssai = NULLP;
8208       if(lcCfg->lcId == SRB2_LCID)
8209          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
8210       else
8211          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
8212    }
8213    if(ulLcCfg)
8214    {
8215       lcCfg->ulLcCfgPres = true;
8216       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
8217    }
8218    else
8219       lcCfg->ulLcCfgPres = false;
8220    return ROK;
8221 }
8222
8223 /*******************************************************************
8224  *
8225  * @brief Function processing LC config info received from CU
8226  *
8227  * @details
8228  *
8229  *    Function : procMacLcCfg
8230  *
8231  *    Functionality: Function processing LC config info received from CU
8232  *
8233  * @params[in] F1AP message
8234  * @return ROK/RFAILED
8235  *
8236  * ****************************************************************/
8237
8238 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
8239 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
8240 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
8241 {
8242    uint8_t ret = ROK;
8243
8244    lcCfg->lcId = lcId;
8245    lcCfg->configType = configType;
8246    if(rbType == RB_TYPE_SRB)
8247    {
8248       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
8249    }
8250    else if(rbType == RB_TYPE_DRB)
8251    {
8252       if(drbItem != NULL)
8253         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
8254       else if(drbSetupModItem != NULL)
8255         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
8256       else if(drbModItem != NULL)
8257         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
8258    }
8259    return ret;
8260 }
8261
8262 /*******************************************************************
8263  *
8264  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
8265  *
8266  * @details
8267  *
8268  *    Function : extractRlcCfgToAddMod
8269  *
8270  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
8271  *
8272  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
8273  *             DuUeCfg Pointer
8274  * @return ROK/RFAILED
8275  *
8276  * ****************************************************************/
8277
8278 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
8279 {
8280   uint8_t idx, rbId, lcId, rlcMode, rbType;
8281   RLC_Config_t *f1RlcCfg = NULLP;
8282   LogicalChannelConfig_t *macUlLcCfg = NULLP;
8283
8284   for(idx = 0; idx < lcCfg->list.count; idx++)
8285   {
8286      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
8287      if(lcCfg->list.array[idx]->servedRadioBearer)
8288      {
8289         /* RadioBearer for SRB/DRB */
8290         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
8291         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
8292         {
8293            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
8294            rbType = RB_TYPE_SRB;
8295         }
8296         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
8297         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
8298         {
8299            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
8300            rbType = RB_TYPE_DRB;
8301         }
8302         else
8303         {
8304            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
8305            return RFAILED;
8306         }
8307         /* MAC UL LC Config */
8308         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
8309         {
8310            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
8311         }
8312      }
8313      else
8314      {
8315         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
8316         return RFAILED;
8317      }
8318      /* RLC Mode Config */
8319      if(lcCfg->list.array[idx]->rlc_Config)
8320      {
8321         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
8322         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
8323      }
8324
8325      /* Filling RLC/MAC Config*/
8326      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
8327      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
8328      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
8329      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
8330      {
8331         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
8332         return RFAILED;
8333      }
8334      (ueCfgDb->numRlcLcs)++;
8335      (ueCfgDb->numMacLcs)++;
8336          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
8337                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
8338   }
8339   //TODO: To send the failure cause in UeContextSetupRsp
8340   return ROK;
8341 }
8342
8343 /*******************************************************************
8344  *
8345  * @brief DeAlloc pdsch serv cell config info
8346  *
8347  * @details
8348  *
8349  *    Function : freeMacPdschServCellInfo
8350  *
8351  *    Functionality: DeAlloc pdsch serv cell config info
8352  *
8353  * @params[in] PdschServCellCfg pointer
8354  * @return void
8355  *
8356  * ****************************************************************/
8357
8358 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
8359 {
8360    if(pdsch->xOverhead)
8361    {
8362       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
8363    }
8364    if(pdsch->codeBlkGrpFlushInd)
8365    {
8366       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
8367    }
8368    if(pdsch->maxCodeBlkGrpPerTb)
8369    {
8370       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8371    }
8372    if(pdsch->maxMimoLayers)
8373    {
8374       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
8375    }
8376 }
8377
8378 /*******************************************************************
8379  *
8380  * @brief Free Serving cell Info
8381  *
8382  * @details
8383  *
8384  *    Function : freeMacServingCellInfo
8385  *
8386  *    Functionality: Free Serving cell Info
8387  *
8388  * @params[in] ServCellCfgInfo *srvCellCfg
8389  * @return void
8390  *
8391  * ****************************************************************/
8392 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
8393 {
8394    uint8_t timeDomRsrcIdx;
8395
8396    if(srvCellCfg->initDlBwp.pdschPresent)
8397    {
8398       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
8399       {
8400          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
8401             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
8402       }
8403    }
8404
8405    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
8406    if(srvCellCfg->bwpInactivityTmr)
8407    {
8408       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8409    }
8410
8411    if(srvCellCfg->initUlBwp.pucchPresent)
8412    {
8413       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8414    }
8415 }
8416
8417 /*******************************************************************
8418  *
8419  * @brief Free cell Grp Cfg Info
8420  *
8421  * @details
8422  *
8423  *    Function : freeUeReCfgCellGrpInfo
8424  *
8425  *    Functionality: Free cell Grp Cfg Info
8426  *
8427  * @params[in] MacUeCfg*  duUeCfg
8428  * @return void
8429  *
8430  * ****************************************************************/
8431
8432 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
8433 {
8434    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
8435 }
8436
8437 /*******************************************************************
8438  *
8439  * @brief Fills Reconfig SchReqReConfig
8440  *
8441  * @details
8442  *
8443  *    Function : extractSchReqReConfig
8444  *
8445  *    Functionality: Fills Reconfig SchReqReConfig
8446  *
8447  * @params[in] SchedulingRequestConfig_t *cuSchedReq
8448  *             SchedReqCfg*  macSchedReq
8449  * @return void
8450  *
8451  * ****************************************************************/
8452 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
8453 {
8454    uint8_t schReqIdx = 0;
8455    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
8456    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
8457
8458    if(cuSchedReq->schedulingRequestToAddModList)
8459    {
8460       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
8461       if(schReqListToAdd->list.count)
8462       {
8463          macSchedReq->addModListCount = schReqListToAdd->list.count;
8464          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
8465          {
8466             macSchedReq->addModList[schReqIdx].schedReqId = \
8467                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
8468             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
8469                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
8470             macSchedReq->addModList[schReqIdx].srTransMax    =\
8471                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
8472          }
8473       }
8474    }
8475    /* Scheduling Req To release */
8476    if(cuSchedReq->schedulingRequestToReleaseList)
8477    {
8478       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
8479       if(schReqListToRel->list.count)
8480       {
8481          macSchedReq->relListCount = schReqListToRel->list.count;
8482          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
8483          {
8484             macSchedReq->relList[schReqIdx] = \
8485                *schReqListToRel->list.array[schReqIdx];
8486          }
8487       }
8488    }
8489 }
8490
8491 /*******************************************************************
8492  *
8493  * @brief Fills TagReconfig
8494  *
8495  * @details
8496  *
8497  *    Function : extractTagReconfig
8498  *
8499  *    Functionality: Fills extractTagReconfig
8500  *
8501  * @params[in] TAG_Config_t *cuTagCfg
8502  *             TagCfg *macTagCfg
8503  * @return void
8504  *
8505  * ****************************************************************/
8506
8507 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
8508 {
8509   uint8_t tagIdx = 0;
8510   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
8511   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
8512
8513   /* Tag config to AddMod */
8514   if(cuTagCfg->tag_ToAddModList)
8515   {
8516      tagListToAddMod = cuTagCfg->tag_ToAddModList;
8517      if(tagListToAddMod->list.count)
8518      {
8519         macTagCfg->addModListCount = tagListToAddMod->list.count;
8520         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
8521         {
8522            macTagCfg->addModList[tagIdx].tagId =\
8523               tagListToAddMod->list.array[tagIdx]->tag_Id;
8524            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8525
8526               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8527         }
8528      }
8529   }
8530   /* Tag config to release */
8531   if(cuTagCfg->tag_ToReleaseList)
8532   {
8533      tagListToRel = cuTagCfg->tag_ToReleaseList;
8534      if(tagListToRel->list.count)
8535      {
8536         macTagCfg->relListCount = tagListToRel->list.count;
8537         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8538         {
8539            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8540         }
8541      }
8542   }
8543 }
8544
8545 /*******************************************************************
8546  *
8547  * @brief Fills PdcchCfg received by CU
8548  *
8549  * @details
8550  *
8551  *    Function : extractPdcchCfg
8552  *
8553  *    Functionality: Fills PdcchCfg received  by CU
8554  *
8555  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8556  *             PdcchConfig *duPdcchCfg
8557  * @return void
8558  *
8559  * ****************************************************************/
8560
8561 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8562 {
8563    uint8_t cRsetIdx = 0;
8564    uint8_t srchSpcIdx = 0;
8565
8566    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8567    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8568    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8569    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8570
8571
8572    /* Control Resource Set To Add/Mod List */
8573    if(cuPdcchCfg->controlResourceSetToAddModList)
8574    {
8575       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8576       if(cRsetToAddModList->list.count)
8577       {
8578          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8579          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8580          {
8581             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8582                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8583             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8584                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8585             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
8586                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
8587                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
8588
8589             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8590                 cRsetToAddModList->list.array[cRsetIdx]->duration;
8591
8592             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8593                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8594             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8595             {
8596                //TODO: handle the case for Interleaved
8597             }
8598             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8599                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8600             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8601             {
8602                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8603                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8604             }
8605          }
8606       }
8607    }
8608    /* Control Resource Set To Release List */
8609    if(cuPdcchCfg->controlResourceSetToReleaseList)
8610    {
8611       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8612       if(cRsetToRelList->list.count)
8613       {
8614          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8615          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8616          {
8617             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8618          }
8619       }
8620    }
8621
8622    /* Search space To Add/Mod List */
8623    if(cuPdcchCfg->searchSpacesToAddModList)
8624    {
8625       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8626       if(srchSpcToAddModList->list.count)
8627       {
8628          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8629          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8630          {
8631             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8632                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8633             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8634                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8635             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8636             {
8637                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8638                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8639             }
8640             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8641             {
8642                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8643                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8644             }
8645             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8646             {
8647                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8648                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8649                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8650                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8651                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8652                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8653
8654                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8655                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8656
8657                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8658                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8659             }
8660             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8661             {
8662                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8663                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8664                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8665                {
8666                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8667                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8668                }
8669
8670             }
8671          }
8672       }
8673    }
8674    /* Search space To Rel List */
8675    if(cuPdcchCfg->searchSpacesToReleaseList)
8676    {
8677       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8678       if(srchSpcToRelList->list.count)
8679       {
8680          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8681          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8682          {
8683             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8684                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
8685          }
8686       }
8687    }
8688 }
8689
8690 /*******************************************************************
8691  *
8692  * @brief Fills PdschCfg received by CU
8693  *
8694  * @details
8695  *
8696  *    Function : extractPdschCfg
8697  *
8698  *    Functionality: Fills PdschCfg received  by CU
8699  *
8700  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8701  *                   which we have stored in F1UeContextSetupDb,
8702  *             PdschConfig *macPdschCfg = Used to Store the information which
8703  *                   needs to send in other layer, as well as this can be the variable
8704  *                   which stores the information in DuCb,
8705  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8706  *                   information to other layer else it will have stored pdsch
8707  *                   configuration in copyOfmacUeCfg.
8708  * @return void
8709  *
8710  * ****************************************************************/
8711
8712 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8713 {
8714    uint8_t timeDomIdx;
8715    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8716
8717    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8718    {
8719       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8720             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8721       {
8722          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8723          {
8724             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8725                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8726          }
8727       }
8728    }
8729    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8730    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8731    {
8732       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8733       if(timeDomAlloc->present ==\
8734             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8735       {
8736          if(timeDomAlloc->choice.setup)
8737          {
8738             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8739             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8740             {
8741                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8742                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8743                {
8744                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8745                   {
8746                      if(storedPdschCfg)
8747                      {
8748                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8749                         {
8750                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8751                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8752                         }
8753                         else
8754                         {
8755                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8756                         }
8757                      }
8758                      else
8759                      {
8760                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8761                      }
8762                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8763                      {
8764                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8765                         return RFAILED;
8766                      }
8767                   }
8768                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8769                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8770                }
8771                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8772                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8773                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8774                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8775             }
8776          }
8777       }
8778    }
8779    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8780    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8781       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8782    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8783    {
8784       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8785       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8786       {
8787          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8788          {
8789             macPdschCfg->bundlingInfo.StaticBundling.size = \
8790                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8791          }
8792       }
8793    }
8794    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8795    {
8796       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8797    }
8798
8799 }
8800
8801 /*******************************************************************
8802  *
8803  * @brief Fills PdschServingCellCfg received by CU
8804  *
8805  * @details
8806  *
8807  *    Function : extractPdschServingCellCfg
8808  *
8809  *    Functionality: Fills PdschCfg received  by CU
8810  *
8811  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8812  *             PdschServCellCfg *macUePdschSrvCellCfg
8813  * @return ROK/RFAILED
8814  *
8815  * ****************************************************************/
8816
8817 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8818 {
8819    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8820    {
8821       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8822       {
8823          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8824          {
8825             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8826                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8827          }
8828          else
8829          {
8830             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8831             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8832             {
8833                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8834                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8835             }
8836             else
8837             {
8838                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8839                return RFAILED;
8840             }
8841          }
8842          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8843          {
8844             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8845                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8846          }
8847          else
8848          {
8849             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8850             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8851             {
8852                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8853                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8854             }
8855             else
8856             {
8857                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8858                return RFAILED;
8859             }
8860          }
8861       }
8862    }
8863    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8864    {
8865       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8866    }
8867    if(cuPdschSrvCellCfg->ext1)
8868    {
8869       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8870       {
8871         if(macUePdschSrvCellCfg->maxMimoLayers)
8872         {
8873            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8874         }
8875         else
8876         {
8877            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8878            if(macUePdschSrvCellCfg->maxMimoLayers)
8879            {
8880               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8881            }
8882            else
8883            {
8884               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8885               return RFAILED;
8886            }
8887         }
8888       }
8889    }
8890    if(cuPdschSrvCellCfg->xOverhead)
8891    {
8892       if(macUePdschSrvCellCfg->xOverhead)
8893       {
8894          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8895       }
8896       else
8897       {
8898          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8899          if(macUePdschSrvCellCfg->xOverhead)
8900          {
8901             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8902          }
8903          else
8904          {
8905             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8906             return RFAILED;
8907          }
8908       }
8909    }
8910    return ROK;
8911 }
8912
8913 /*******************************************************************
8914  *
8915  * @brief Fills PuschCfg received by CU
8916  *
8917  * @details
8918  *
8919  *    Function : extractPuschCfg
8920  *
8921  *    Functionality: Fills PuschCfg received  by CU
8922  *
8923  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8924  *             PuschCfg *macPuschCfg
8925  * @return void
8926  *
8927  * ****************************************************************/
8928
8929 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8930 {
8931    uint8_t timeDomIdx = 0;
8932    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8933    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8934
8935    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8936    {
8937       if(cuPuschCfg->choice.setup)
8938       {
8939          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8940          {
8941              macPuschCfg->dataScramblingId = \
8942                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8943          }
8944          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8945          {
8946             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8947             {
8948                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8949                {
8950                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8951                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8952                   {
8953                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8954                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8955                   }
8956                   if(dmrsUlCfg->transformPrecodingDisabled)
8957                   {
8958                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8959                      {
8960                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8961                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8962                      }
8963                   }
8964                }
8965             }
8966          }
8967          /*Res Alloc Type for UL */
8968          if(cuPuschCfg->choice.setup->resourceAllocation)
8969          {
8970             macPuschCfg->resourceAllocType = \
8971                cuPuschCfg->choice.setup->resourceAllocation;
8972          }
8973          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8974          {
8975             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8976             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8977             {
8978                if(timeDomAllocList->choice.setup)
8979                {
8980                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8981                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8982                   {
8983                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8984                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8985                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8986                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8987                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8988                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8989                   }
8990                }
8991             }
8992          }
8993          if(cuPuschCfg->choice.setup->transformPrecoder)
8994             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8995       }
8996    }
8997 }
8998
8999 /*******************************************************************
9000  *
9001  * @brief Function to fill pucch Power Control
9002  *
9003  * @details
9004  *
9005  *    Function : extractPucchPowerControl
9006  *
9007  *    Functionality: Function to fill pucch Power Control
9008  *
9009  * @params[in] PucchPowerControl *pwrCtrl,
9010  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
9011  * @return void
9012  *
9013  * ****************************************************************/
9014
9015 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
9016 {
9017    uint8_t arrIdx;
9018
9019    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
9020       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
9021    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
9022       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
9023    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
9024       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
9025    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
9026       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
9027    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
9028       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
9029    if(cuPwrCtrlCfg->p0_Set)
9030    {
9031       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
9032       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
9033       {
9034          pwrCtrl->p0Set[arrIdx].p0PucchId =\
9035             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
9036          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
9037             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
9038       }
9039    }
9040    if(cuPwrCtrlCfg->pathlossReferenceRSs)
9041    {
9042       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
9043       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
9044       {
9045          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
9046             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
9047       }
9048    }
9049 }
9050
9051  /*******************************************************************
9052  *
9053  * @brief Function to extractResrcSetToAddModList sent by CU
9054  *
9055  * @details
9056  *
9057  *    Function : extractResrcSetToAddModList
9058  *
9059  *    Functionality: Fucntion to extractResrcSetToAddModList
9060  *
9061  * @params[in] PucchResrcSetCfg pointer,
9062  *             struct PUCCH_Config__resourceSetToAddModList pointer
9063  * @return void
9064  *
9065  * ****************************************************************/
9066
9067 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
9068 {
9069    uint8_t arrIdx, rsrcListIdx;
9070
9071    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
9072    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
9073    {
9074       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
9075          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
9076       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
9077          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
9078       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
9079       {
9080          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
9081             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
9082       }
9083
9084       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
9085       {
9086          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
9087             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
9088       }
9089       else
9090       {
9091          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
9092       }
9093    }
9094 }/* End of extractResrcSetToAddModList */
9095
9096 /*******************************************************************
9097  *
9098  * @brief Fills extractResrcToAddModList sent by CU
9099  *
9100  * @details
9101  *
9102  *    Function : extractResrcToAddModList
9103  *
9104  *    Functionality: Fills extractResrcToAddModList
9105  *
9106  * @params[in] PucchResrcCfg pointer,
9107  *             struct PUCCH_Config__resourceToAddModList pointer
9108  * @return ROk/RFAILED
9109  *
9110  * ****************************************************************/
9111
9112 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
9113 {
9114    uint8_t arrIdx;
9115
9116    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
9117    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
9118    {
9119       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
9120         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
9121       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
9122         cuResrcList->list.array[arrIdx]->startingPRB;
9123       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
9124       {
9125          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
9126            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
9127       }
9128       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
9129       {
9130          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
9131            *cuResrcList->list.array[arrIdx]->secondHopPRB;
9132       }
9133       /* PUCCH RSRC FORMAT */
9134       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
9135       {
9136          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
9137          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
9138          {
9139             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
9140             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
9141             {
9142                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
9143                return RFAILED;
9144             }
9145             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
9146                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
9147             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
9148                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
9149             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
9150                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
9151          }
9152       }
9153       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
9154       {
9155          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
9156          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
9157          {
9158             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
9159             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
9160             {
9161                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
9162                return RFAILED;
9163             }
9164             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
9165                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
9166             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
9167                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
9168             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
9169                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
9170             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
9171                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
9172          }
9173       }
9174       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
9175       {
9176          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
9177          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
9178          {
9179             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
9180             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
9181             {
9182                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
9183                return RFAILED;
9184             }
9185             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
9186                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
9187             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
9188                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
9189             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
9190                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
9191          }
9192       }
9193       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
9194       {
9195          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
9196          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
9197          {
9198             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
9199             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
9200             {
9201                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
9202                return RFAILED;
9203             }
9204             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
9205                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
9206             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
9207                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
9208             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
9209                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
9210          }
9211       }
9212       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
9213       {
9214          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
9215          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
9216          {
9217             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
9218             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
9219             {
9220                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
9221                return RFAILED;
9222             }
9223             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
9224                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
9225             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
9226                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
9227             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
9228                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
9229             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
9230                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
9231          }
9232       }
9233    }
9234    return ROK;
9235
9236 }/* End of extractResrcToAddModList */
9237
9238 /*******************************************************************
9239  *
9240  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
9241  *
9242  * @details
9243  *
9244  *    Function : fillPucchSchedReqPeriodAndOffset
9245  *
9246  *    Functionality: To fillPucchSchedReqPeriodAndOffset
9247  *
9248  * @params[in] macPeriodicty,
9249  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
9250  * @return void
9251  *
9252  * ****************************************************************/
9253
9254 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
9255    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
9256 {
9257    macPeriodicty = cuPeriodicty->present;
9258    switch(macPeriodicty)
9259    {
9260       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
9261          {
9262             macOffset     = cuPeriodicty->choice.sym2;
9263             break;
9264          }
9265       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
9266          {
9267             macOffset     = cuPeriodicty->choice.sym6or7;
9268             break;
9269          }
9270       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
9271          {
9272             macOffset     = cuPeriodicty->choice.sl1;
9273             break;
9274          }
9275       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
9276          {
9277             macOffset = cuPeriodicty->choice.sl2;
9278             break;
9279          }
9280       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
9281          {
9282             macOffset = cuPeriodicty->choice.sl4;
9283             break;
9284          }
9285       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
9286          {
9287             macOffset = cuPeriodicty->choice.sl5;
9288             break;
9289          }
9290       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
9291          {
9292             macOffset = cuPeriodicty->choice.sl8;
9293             break;
9294          }
9295       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
9296          {
9297             macOffset = cuPeriodicty->choice.sl10;
9298             break;
9299          }
9300       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
9301          {
9302             macOffset = cuPeriodicty->choice.sl16;
9303             break;
9304          }
9305       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
9306          {
9307             macOffset = cuPeriodicty->choice.sl20;
9308             break;
9309          }
9310       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
9311          {
9312             macOffset = cuPeriodicty->choice.sl40;
9313             break;
9314          }
9315       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
9316          {
9317             macOffset = cuPeriodicty->choice.sl80;
9318             break;
9319          }
9320       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
9321          {
9322             macOffset = cuPeriodicty->choice.sl160;
9323             break;
9324          }
9325       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
9326          {
9327             macOffset = cuPeriodicty->choice.sl320;
9328             break;
9329          }
9330       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
9331          {
9332             macOffset = cuPeriodicty->choice.sl640;
9333             break;
9334          }
9335       default :
9336          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
9337    }
9338 }
9339
9340 /*******************************************************************
9341  *
9342  * @brief Function to extractPucchFormatCfg sent by CU
9343  *
9344  * @details
9345  *
9346  *    Function : extractPucchFormatCfg
9347  *
9348  *    Functionality: Function to extractPucchFormatCfg
9349  *
9350  * @params[in] PucchFormatCfg pointer,
9351  *             PUCCH_FormatConfig_t pointer
9352  * @return void
9353  *
9354  * ****************************************************************/
9355
9356 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
9357  {
9358     if(cuFormatCfg->interslotFrequencyHopping)
9359        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
9360     if(cuFormatCfg->additionalDMRS)
9361        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
9362     if(cuFormatCfg->maxCodeRate)
9363        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
9364     if(cuFormatCfg->nrofSlots)
9365        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
9366     if(cuFormatCfg->pi2BPSK)
9367        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
9368     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
9369        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
9370  }/* End of extractPucchFormatCfg */
9371
9372 /*******************************************************************
9373  *
9374  * @brief Function to extractSchedReqCfgToAddMod sent by CU
9375  *
9376  * @details
9377  *
9378  *    Function : extractSchedReqCfgToAddMod
9379  *
9380  *    Functionality: Function to extractSchedReqCfgToAddMod
9381  *
9382  * @params[in] PucchSchedReqCfg pointer,
9383  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
9384  * @return void
9385  *
9386  * ****************************************************************/
9387
9388 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
9389 {
9390    uint8_t arrIdx;
9391
9392    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
9393    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
9394    {
9395       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
9396          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
9397       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
9398          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
9399       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
9400       {
9401          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
9402             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
9403       }
9404       if(cuSchedReqList->list.array[arrIdx]->resource)
9405       {
9406          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
9407             *cuSchedReqList->list.array[arrIdx]->resource;
9408       }
9409    }
9410
9411 }/* End of extractSchedReqCfgToAddMod */
9412
9413  /*******************************************************************
9414  *
9415  * @brief Fills PucchCfg received by CU
9416  *
9417  * @details
9418  *
9419  *    Function : extractPucchCfg
9420  *
9421  *    Functionality: Fills PucchCfg received  by CU
9422  *
9423  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
9424  *                is send by CU, which we have stored in F1UeContextSetupDb,
9425  *             PucchCfg *macPucchCfg = Used to Store the information which
9426  *                needs to send in other layer, as well as this can be the variable
9427  *                which stores the information in DuCb,
9428  *             PucchCfg *storedPucchCfg = Null in case of sending the
9429  *                information to other layer else it will have Pucch Cfg which
9430  *                we have stored in copyOfmacUeCfg.
9431  * @return ROK/RFAILED
9432  *
9433  * ****************************************************************/
9434
9435 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
9436 PucchCfg *storedPucchCfg)
9437 {
9438    uint8_t arrIdx;
9439
9440    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
9441    {
9442       if(cuPucchCfg->choice.setup)
9443       {
9444          /* Resource Set Cfg */
9445          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
9446          {
9447             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
9448             if(macPucchCfg->resrcSet == NULLP)
9449             {
9450                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
9451                return RFAILED;
9452             }
9453             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
9454             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
9455          }
9456
9457          /* Resource Cfg */
9458          if(cuPucchCfg->choice.setup->resourceToAddModList)
9459          {
9460             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
9461             if(macPucchCfg->resrc == NULLP)
9462             {
9463                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
9464                return RFAILED;
9465             }
9466             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
9467             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
9468          }
9469
9470          /* Format 1 Cfg */
9471          if(cuPucchCfg->choice.setup->format1)
9472          {
9473             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
9474             if(macPucchCfg->format1 == NULLP)
9475             {
9476                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
9477                return RFAILED;
9478             }
9479             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
9480             extractPucchFormatCfg(macPucchCfg->format1,\
9481                cuPucchCfg->choice.setup->format1->choice.setup);
9482          }
9483
9484          /* Format 2 Cfg */
9485          if(cuPucchCfg->choice.setup->format2)
9486          {
9487             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
9488             if(macPucchCfg->format2 == NULLP)
9489             {
9490                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
9491                return RFAILED;
9492             }
9493             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
9494             extractPucchFormatCfg(macPucchCfg->format2,\
9495                cuPucchCfg->choice.setup->format2->choice.setup);
9496          }
9497
9498          /* Format 3 Cfg */
9499          if(cuPucchCfg->choice.setup->format3)
9500          {
9501             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
9502             if(macPucchCfg->format3 == NULLP)
9503             {
9504                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
9505                return RFAILED;
9506             }
9507             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
9508             extractPucchFormatCfg(macPucchCfg->format3,\
9509                cuPucchCfg->choice.setup->format3->choice.setup);
9510          }
9511
9512          /* Format 4 Cfg */
9513          if(cuPucchCfg->choice.setup->format4)
9514          {
9515             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
9516             if(macPucchCfg->format4 == NULLP)
9517             {
9518                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
9519                return RFAILED;
9520             }
9521             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
9522             extractPucchFormatCfg(macPucchCfg->format4,\
9523                cuPucchCfg->choice.setup->format4->choice.setup);
9524          }
9525
9526          /* Sched Req List */
9527          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
9528          {
9529             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
9530             if(macPucchCfg->schedReq == NULLP)
9531             {
9532                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
9533                return RFAILED;
9534             }
9535             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9536             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9537             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9538          }
9539
9540          /*TODO: Add support for  Spatial Info */
9541
9542          /* MultiCsiCfg */
9543          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9544          {
9545             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9546             if(macPucchCfg->multiCsiCfg == NULLP)
9547             {
9548                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9549                return RFAILED;
9550             }
9551             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9552             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9553             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9554             {
9555                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9556                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9557             }
9558          }
9559
9560          /* Dl_DataToUL_ACK */
9561          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9562     {
9563        if(storedPucchCfg)
9564        {
9565           if(storedPucchCfg->dlDataToUlAck)
9566           {
9567              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9568           }
9569           else
9570           {
9571             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9572           }
9573        }
9574        else
9575        {
9576           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9577        }
9578        if(macPucchCfg->dlDataToUlAck == NULLP)
9579        {
9580           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9581           return RFAILED;
9582        }
9583        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9584        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9585        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9586        {
9587           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9588           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9589        }
9590          }
9591
9592          /* Power Control */
9593          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9594          {
9595             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9596             if(macPucchCfg->powerControl == NULLP)
9597             {
9598                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9599                return RFAILED;
9600             }
9601             extractPucchPowerControl(macPucchCfg->powerControl,\
9602                cuPucchCfg->choice.setup->pucch_PowerControl);
9603          }
9604       }
9605    }
9606    return ROK;
9607 }
9608
9609 /*******************************************************************
9610  *
9611  * @brief Fills ServingCellReconfig received by CU
9612  *
9613  * @details
9614  *
9615  *    Function : extractSpCellDedicatedCfg
9616  *
9617  *    Functionality: Fills ServingCellReconfig received  by CU
9618  *
9619  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9620  *                  CU, which we have stored in F1UeContextSetupDb,
9621  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9622  *                  which  needs to send in other layer, as well as this can be the
9623  *                  variable which stores the information in DuCb,
9624  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9625  *                  information to other layer else it will have ServCellCfgInfo which
9626  *                  we have stored in copyOfmacUeCfg.
9627  * @return ROK/RFAILD
9628  *
9629  * ****************************************************************/
9630 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9631 ServCellCfgInfo *storedSrvCellCfg)
9632 {
9633    uint8_t ret = ROK;
9634    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9635    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9636
9637    if(cuSrvCellCfg->initialDownlinkBWP)
9638    {
9639       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9640       if(dlBwp->pdcch_Config)
9641       {
9642          if(dlBwp->pdcch_Config->choice.setup)
9643          {
9644             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9645             if(storedSrvCellCfg)
9646             {
9647                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
9648                {
9649                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9650                }
9651                else
9652                {
9653                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9654                }
9655             }
9656             else
9657             {
9658                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9659             }
9660          }
9661       }
9662       if(dlBwp->pdsch_Config)
9663       {
9664          if(dlBwp->pdsch_Config->choice.setup)
9665          {
9666             macSrvCellCfg->initDlBwp.pdschPresent = true;
9667
9668             if(storedSrvCellCfg)
9669             {
9670                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9671                {
9672                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9673                }
9674                else
9675                {
9676                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9677                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9678                }
9679             }
9680             else
9681             {
9682                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9683             }
9684          }
9685       }
9686    }
9687    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9688       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9689    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9690       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9691    if(cuSrvCellCfg->bwp_InactivityTimer)
9692    {
9693       if(macSrvCellCfg->bwpInactivityTmr)
9694       {
9695          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9696       }
9697       else
9698       {
9699          macSrvCellCfg->bwpInactivityTmr = NULLP;
9700          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9701          if(macSrvCellCfg->bwpInactivityTmr)
9702          {
9703             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9704          }
9705          else
9706          {
9707             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9708             return RFAILED;
9709          }
9710       }
9711    }
9712    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9713    {
9714       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9715       {
9716          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9717          if(ret == RFAILED)
9718          {
9719             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9720             return RFAILED;
9721          }
9722       }
9723    }
9724    if(cuSrvCellCfg->uplinkConfig)
9725    {
9726       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9727       {
9728          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9729          if(ulBwp->pusch_Config)
9730          {
9731             macSrvCellCfg->initUlBwp.puschPresent = true;
9732             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9733          }
9734          if(ulBwp->pucch_Config)
9735          {
9736             macSrvCellCfg->initUlBwp.pucchPresent = true;
9737             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9738             if(storedSrvCellCfg)
9739             {
9740                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9741                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9742                else
9743                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9744                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9745             }
9746             else
9747             {
9748                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9749             }
9750          }
9751       }
9752       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9753          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9754    }
9755    return ret;
9756 }
9757 /*******************************************************************
9758  *
9759  * @brief Fills Reconfig Cell group Info received by CU
9760  *
9761  * @details
9762  *
9763  *    Function : extractUeReCfgCellInfo
9764  *
9765  *    Functionality: Fills Reconfig Cell group Info received by CU
9766  *
9767  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9768  *                       is send by CU, which we have stored in F1UeContextSetupDb
9769  *             MacUeCfg *MacUeCfg = Used to Store the information,
9770  *                      which needs to send in other layer, as well as this can be
9771  *                      the variable which stores the information in DuCb,
9772  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9773  *                      information to other layer else it will have copyOfmacUeCfg
9774  *                      which we have stored in F1UeContextSetupDb.
9775  *
9776  * @return ROK/RFAILED
9777  *
9778  * ****************************************************************/
9779 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9780 {
9781    uint8_t ret = ROK;
9782    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9783    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9784    SpCellConfig_t            *spcellCfg = NULLP;
9785    ServingCellConfig_t       *servCellCfg = NULLP;
9786
9787    if(cellGrp)
9788    {
9789       /* Fill MacCell Group Reconfig  */
9790       if(cellGrp->mac_CellGroupConfig)
9791       {
9792          macUeCfg->macCellGrpCfgPres = true;
9793          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9794          if(macCellGroup->schedulingRequestConfig)
9795          {
9796             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9797          }
9798          if(macCellGroup->tag_Config)
9799          {
9800             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9801          }
9802          if(macCellGroup->bsr_Config)
9803          {
9804             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9805             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9806             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9807             {
9808                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9809                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9810             }
9811          }
9812          if(macCellGroup->phr_Config)
9813          {
9814             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9815             {
9816                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9817                if(macCellGroup->phr_Config->choice.setup)
9818                {
9819                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9820                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9821                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9822                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9823                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9824                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9825                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9826                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9827                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9828                   macCellGroup->phr_Config->choice.setup->dummy;
9829                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9830                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9831                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9832                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9833                }
9834             }
9835          }
9836       }
9837       /* Fill Physical Cell Group Reconfig */
9838       if(cellGrp->physicalCellGroupConfig)
9839       {
9840          macUeCfg->phyCellGrpCfgPres = true;
9841          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9842          if(phyCellGrpCfg->p_NR_FR1)
9843          {
9844             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9845                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9846          }
9847          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9848       }
9849       /* Fill SpCell Reconfig */
9850       if(cellGrp->spCellConfig)
9851       {
9852          macUeCfg->spCellCfgPres = true;
9853          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9854          if(spcellCfg->servCellIndex)
9855          {
9856             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9857          }
9858          /* Fill Serving cell Reconfig info */
9859          if(cellGrp->spCellConfig->spCellConfigDedicated)
9860          {
9861             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9862             if(storedMacUeCfg)
9863             {
9864                if(!storedMacUeCfg->spCellCfgPres)
9865                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9866                else
9867                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9868                         &storedMacUeCfg->spCellCfg.servCellCfg);
9869             }
9870             else
9871             {
9872                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9873             }
9874             if(ret == RFAILED)
9875             {
9876                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9877             }
9878          }
9879       }
9880    }
9881    return ret;
9882 }
9883 /*******************************************************************
9884 *
9885 * @brief free the memory allocated by decoder
9886 *
9887 * @details
9888 *
9889 *    Function : freeAperDecodeNrcgi
9890 *
9891 *    Functionality: Free Nrcgi values
9892 *
9893 * @params[in] NRCGI_t *nrcgi
9894 * @return void
9895 *
9896 * ****************************************************************/
9897
9898
9899 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9900 {
9901     if(nrcgi->pLMN_Identity.buf != NULLP)
9902     {
9903        free(nrcgi->pLMN_Identity.buf);
9904     }
9905     if(nrcgi->nRCellIdentity.buf != NULLP)
9906     {
9907        free(nrcgi->nRCellIdentity.buf);
9908     }
9909 }
9910 /*******************************************************************
9911 *
9912 * @brief free the memory allocated by decoder
9913 *
9914 * @details
9915 *
9916 *    Function : freeAperDecodeCuToDuInfo
9917 *
9918 *    Functionality:  Free Cu To Du Information
9919 *
9920 * @params[in] CUtoDURRCInformation_t *rrcMsg
9921 * @return void
9922 *
9923 * ****************************************************************/
9924
9925
9926 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9927 {
9928    uint8_t ieIdx =0;
9929    uint8_t arrIdx =0;
9930
9931    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9932    {
9933       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9934          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9935       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9936    }
9937
9938    if(rrcMsg->iE_Extensions)
9939    {
9940       if(rrcMsg->iE_Extensions->list.array)
9941       {
9942          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9943          {
9944             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9945             {
9946                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9947                {
9948                   case ProtocolIE_ID_id_CellGroupConfig:
9949                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9950                      {
9951                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9952                      }
9953                      break;
9954                   default:
9955                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9956                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9957                      break;
9958                }
9959             }
9960          }
9961          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9962          {
9963             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9964          }
9965          free(rrcMsg->iE_Extensions->list.array);
9966
9967       }
9968
9969       free(rrcMsg->iE_Extensions);
9970    }
9971 }
9972 /*******************************************************************
9973 *
9974 * @brief free the memory allocated by decoder
9975 *
9976 * @details
9977 *
9978 *    Function : freeAperDecodeSplCellList
9979 *
9980 *    Functionality: Free Spl Cell List
9981                     where memory allocated by aper_decoder
9982 *
9983 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9984 * @return void
9985 *
9986 * ****************************************************************/
9987
9988
9989 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9990 {
9991     uint8_t  cellIdx =0;
9992
9993     if(spCellLst->list.array != NULLP)
9994     {
9995        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9996        {
9997           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9998           {
9999              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
10000           }
10001           if(spCellLst->list.array[cellIdx]!=NULLP)
10002           {
10003              free(spCellLst->list.array[cellIdx]);
10004           }
10005        }
10006        free(spCellLst->list.array);
10007     }
10008 }
10009 /*******************************************************************
10010 *
10011 * @brief free the memory allocated by decoder
10012 *
10013 * @details
10014 *
10015 *    Function : freeAperDecodeSRBSetup
10016 *
10017 *    Functionality: added free part for the memory allocated by aper_decoder
10018 *
10019 * @params[in] SRBs_ToBeSetup_List_t *srbSet
10020 * @return void
10021 *
10022 ****************************************************************/
10023
10024
10025 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
10026 {
10027     uint8_t srbIdx =0;
10028     if(srbSet->list.array != NULLP)
10029     {
10030        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
10031        {
10032           if(srbSet->list.array[srbIdx]!=NULLP)
10033           {
10034              free(srbSet->list.array[srbIdx]);
10035           }
10036        }
10037        free(srbSet->list.array);
10038     }
10039 }
10040
10041 /*******************************************************************
10042 *
10043 * @brief free the memory allocated by decoder
10044 *
10045 * @details
10046 *
10047 *    Function : freeAperDecodeULTnlInfo
10048 *
10049 *    Functionality: added free part for the memory allocated by aper_decoder
10050 *
10051 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10052 * @return void
10053 *
10054 * ****************************************************************/
10055
10056
10057 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
10058 {
10059    uint8_t ulIdx=0;
10060    if(ulInfo->list.array != NULLP)
10061    {
10062       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
10063       {
10064          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
10065          {
10066             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
10067             {
10068                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10069                      transportLayerAddress.buf != NULLP)
10070                {
10071                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10072                         !=NULLP)
10073                   {
10074                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
10075                   }
10076                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10077                         transportLayerAddress.buf);
10078                }
10079                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
10080             }
10081          }
10082          if(ulInfo->list.array[ulIdx]!=NULLP)
10083          {
10084             free(ulInfo->list.array[ulIdx]);
10085          }
10086       }
10087       free(ulInfo->list.array);
10088    }
10089 }
10090 /*******************************************************************
10091 *
10092 * @brief free the memory allocated by decoder
10093 *
10094 * @details
10095 *
10096 *    Function : freeAperDecodeDRBSetup
10097 *
10098 *    Functionality: free DRBSetup which is allocated by decoder
10099 *
10100 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
10101 * @return void
10102 *
10103 * ****************************************************************/
10104
10105 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
10106 {
10107    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
10108    uint8_t  flowIdx =0;
10109    uint8_t  drbIdx =0;
10110
10111    if(drbSet->list.array != NULLP)
10112    {
10113       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
10114       {
10115          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
10116          {
10117             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10118             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
10119             {
10120                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10121                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
10122                {
10123                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10124                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
10125                   {
10126                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10127                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
10128                      {
10129
10130                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
10131                         {
10132
10133                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
10134                            {
10135
10136                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
10137                                     buf!=NULLP)
10138                               {
10139
10140                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
10141                                        flows_Mapped_To_DRB_List.list.array != NULLP)
10142                                  {
10143
10144                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10145                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
10146                                     {
10147
10148                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10149                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
10150                                        {
10151                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10152                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10153                                                 qoSFlowLevelQoSParameters.\
10154                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
10155                                           {
10156                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10157                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10158                                                    qoSFlowLevelQoSParameters.\
10159                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
10160                                              {
10161
10162                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10163                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10164                                                       qoSFlowLevelQoSParameters.\
10165                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
10166                                                 {
10167
10168
10169                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10170                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10171                                                          qoSFlowLevelQoSParameters.\
10172                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
10173                                                 }
10174
10175                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10176                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10177                                                       qoSFlowLevelQoSParameters.\
10178                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
10179                                              }
10180
10181                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10182
10183                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10184                                                    qoSFlowLevelQoSParameters.\
10185                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
10186                                           }
10187                                        }
10188                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10189                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
10190                                        {
10191
10192                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10193                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
10194                                        }
10195                                     }
10196
10197                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10198                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
10199                                  }
10200
10201                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10202                                        DRB_Information.sNSSAI.sD->buf);
10203                               }
10204
10205                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
10206                            }
10207
10208                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
10209
10210                         }
10211
10212                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10213
10214                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
10215                      }
10216
10217                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10218                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
10219                   }
10220
10221                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10222                         qoS_Characteristics.choice.non_Dynamic_5QI);
10223                }
10224                free(drbSetItem->qoSInformation.choice.choice_extension);
10225             }
10226             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
10227             if(drbSetItem->uLConfiguration)
10228             {
10229                free(drbSetItem->uLConfiguration);
10230             }
10231          }
10232          if(drbSet->list.array[drbIdx]!=NULLP)
10233          {
10234             free(drbSet->list.array[drbIdx]);
10235          }
10236       }
10237       free(drbSet->list.array);
10238    }
10239 }
10240
10241
10242 /*******************************************************************
10243  *
10244  * @brief builds Mac Cell Cfg
10245  *
10246  * @details
10247  *
10248  *    Function : procUeReCfgCellInfo
10249  *
10250  *    Functionality: builds Mac Cell Cfg
10251  *
10252  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
10253  *                       needs to send in other layer, as well as this can be
10254  *                       the variable which stores the information in DuCb.
10255  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
10256  *                       information to other layer else it will have copyOfmacUeCfg
10257  *                       which we have stored in F1UeContextSetupDb
10258  *             void *cellInfo = CellGroupConfigRrc_t information which is send
10259  *                        by CU, which we have stored in F1UeContextSetupDb
10260  *
10261  * @return void
10262  *
10263  * ****************************************************************/
10264 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
10265 {
10266    uint8_t ret = ROK;
10267    CellGroupConfigRrc_t *cellGrp = NULLP;
10268
10269    if(cellInfo)
10270    {
10271       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
10272       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
10273       if(ret == RFAILED)
10274          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
10275    }
10276    if(ret == RFAILED)
10277    {
10278       freeUeReCfgCellGrpInfo(macUeCfgToSend);
10279    }
10280    return ret;
10281 }
10282
10283 /*******************************************************************
10284  *
10285  * @brief Filling modulation info in mac ue cfg
10286  *
10287  * @details
10288  *
10289  *    Function : duFillModulationDetails
10290  *
10291  *    Functionality: Filling modulation info in mac ue cfg
10292  *
10293  * @params[in] MAC UE Config to be updated
10294  *             Current UE configuration
10295  *             UE NR capability from CU
10296  * @return ROK     - success
10297  *         RFAILED - failure
10298  *
10299  * ****************************************************************/
10300 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
10301 {
10302    UE_NR_Capability_t *ueNrCap=NULLP;
10303
10304    if(!ueCap)
10305    {
10306       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
10307       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10308    }
10309    else
10310    {
10311       ueNrCap = (UE_NR_Capability_t *)ueCap;
10312
10313       /* Filling DL modulation info */
10314       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
10315          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
10316          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
10317       {
10318          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
10319          {
10320             case ModulationOrder_qpsk:
10321                {
10322                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
10323                   break;
10324                }
10325             case ModulationOrder_qam16:
10326                {
10327                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
10328                   break;
10329                }
10330             case ModulationOrder_qam64:
10331                {
10332                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
10333                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
10334                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
10335                   break;
10336                }
10337             case ModulationOrder_qam256:
10338                {
10339                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
10340                   break;
10341                }
10342             default:
10343                {
10344                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
10345                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
10346                   break;
10347                }
10348          }
10349       }
10350       else
10351       {
10352          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
10353       }
10354
10355       /* Filling UL modulation info */
10356       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
10357          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
10358          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
10359       {
10360          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
10361          {
10362             case ModulationOrder_qpsk:
10363                {
10364                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
10365                   break;
10366                }
10367             case ModulationOrder_qam16:
10368                {
10369                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
10370                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
10371                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
10372                   break;
10373                }
10374             case ModulationOrder_qam64:
10375                {
10376                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
10377                   break;
10378                }
10379             case ModulationOrder_qam256:
10380                {
10381                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
10382                   break;
10383                }
10384             default:
10385                {
10386                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
10387                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10388                   break;
10389                }
10390          }
10391       }
10392       else
10393       {
10394          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10395       }
10396    }
10397 }
10398
10399 /*******************************************************************
10400  *
10401  * @brief Function to extract cellGrp Info present in cutoDu cont
10402  *
10403  * @details
10404  *
10405  *    Function : extractCellGrpInfo
10406  *
10407  *    Functionality: Function to extract cellGrp Info present
10408  *                   in cutoDu cont
10409  *
10410  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
10411  *
10412  * @return CellGroupConfigRrc_t *
10413  *
10414  * ****************************************************************/
10415
10416 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
10417       DuUeCfg *ueCfgDb)
10418 {
10419    uint8_t idx2 =0;
10420    uint16_t id =0;
10421    uint16_t recvBufLen =0;
10422    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
10423    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
10424    asn_dec_rval_t rval; /* Decoder return value */
10425    memset(&rval, 0, sizeof(asn_dec_rval_t));
10426
10427    if(protocolIeExtn)
10428    {
10429       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
10430       {
10431          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
10432          id = extIeInfo->id;
10433          switch(id)
10434          {
10435             case ProtocolIE_ID_id_CellGroupConfig:
10436             {
10437                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
10438                /* decoding the CellGroup Buf received */
10439                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
10440                if(cellGrpCfg)
10441                {
10442                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
10443                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
10444                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
10445                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10446                   {
10447                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10448                      return NULLP;
10449                   }
10450                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
10451                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
10452                      return NULLP;
10453                }
10454                break;
10455             }
10456             default:
10457                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
10458                break;
10459          }
10460       }
10461    }
10462    return cellGrpCfg;
10463 }
10464
10465 /*******************************************************************
10466  *
10467  * @brief Fills Srb List received by CU
10468  *
10469  * @details
10470  *
10471  *    Function : procSrbListToSetup
10472  *
10473  *    Functionality: Fills Srb List received  by CU
10474  *
10475  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
10476  *             LcCfg pointer
10477  *             RlcBearerCfg pointer
10478  * @return void
10479  *
10480  * ****************************************************************/
10481 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
10482 {
10483
10484    /* Filling RLC INFO */
10485    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
10486
10487    /* Filling MAC INFO */
10488    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
10489    {
10490       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
10491       return RFAILED;
10492    }
10493
10494    return ROK;
10495 }
10496
10497
10498
10499 /*******************************************************************
10500  *
10501  * @brief extract Srb List received by CU
10502  *
10503  * @details
10504  *
10505  *    Function : extractSrbListToSetup
10506  *
10507  *    Functionality: extract Srb List received by CU
10508  *                   for both MAC and RLC
10509  *
10510  * @params[in] SRBs_ToBeSetup_Item_t pointer
10511  *             DuUeCfg pointer
10512  * @return ROK/RFAIED
10513  *
10514  * ****************************************************************/
10515
10516 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
10517 {
10518    uint8_t ret, srbIdx;
10519    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
10520
10521    if(srbCfg)
10522    {
10523       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
10524       {
10525          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
10526          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10527          {
10528             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
10529             ret = RFAILED;
10530             break;
10531          }
10532          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10533          {
10534             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
10535             ret = RFAILED;
10536             break;
10537          }
10538          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10539          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10540          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10541             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
10542          ueCfgDb->numRlcLcs++;
10543          ueCfgDb->numMacLcs++;
10544          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10545                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10546          if(ret == RFAILED)
10547          {
10548             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10549             break;
10550          }
10551       }
10552    }
10553    else
10554       ret = RFAILED;
10555
10556    return ret;
10557 }
10558
10559 /*******************************************************************
10560  *
10561  * @brief Fills Drb List received by CU
10562  *
10563  * @details
10564  *
10565  *    Function : procDrbListToSetupMod
10566  *
10567  *    Functionality: Fills Drb List received by CU
10568  *                   for both MAC and RLC
10569  *
10570  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
10571  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
10572  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
10573  * @return void
10574  *
10575  * ****************************************************************/
10576
10577 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10578 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
10579 {
10580    uint8_t cfgIdx = 0;
10581    RlcMode rlcModeInfo;
10582
10583    if(drbItem != NULLP)
10584    {
10585       /* Filling RLC INFO */
10586       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
10587       qoSInformation);
10588
10589       /* Filling MAC INFO */
10590       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10591       {
10592          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10593          return RFAILED;
10594       }
10595    }
10596    else if(drbSetupModItem != NULLP)
10597    {
10598       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
10599       &drbSetupModItem->qoSInformation);
10600
10601       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10602       {
10603          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10604          return RFAILED;
10605       }
10606    }
10607    else if(drbModItem != NULLP)
10608    {
10609       /* Drb to Mod IEs doesnot have rlcMode to be modified
10610        * in ASN. Hence no change in RLC configurations */
10611       if(storedRlcUeCfg != NULLP)
10612       {
10613          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
10614          {
10615             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
10616             {
10617                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
10618                break;
10619             }
10620          }
10621       }
10622
10623       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
10624       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10625       {
10626          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10627          return RFAILED;
10628       }
10629    }
10630    return ROK;
10631 }
10632
10633 /*******************************************************************
10634  *
10635  * @brief extract Drb List received by CU
10636  *
10637  * @details
10638  *
10639  *    Function : extractDrbListToSetupMod
10640  *
10641  *    Functionality: extract Drb List received by CU
10642  *                   for both MAC and RLC
10643  *
10644  * @params[in] DRBs_ToBeSetup_Item_t pointer
10645  *             DuUeCfg pointer
10646  * @return ROK/RFAIED
10647  *
10648  * ****************************************************************/
10649
10650 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10651  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
10652 {
10653    uint8_t ret, drbIdx = 0, lcId = 0;
10654    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10655    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10656    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
10657
10658    ret = ROK;
10659    if(drbCount > 0)
10660    {
10661       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10662       {
10663          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10664          {
10665             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
10666             ret = RFAILED;
10667             break;
10668          }
10669          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10670          {
10671             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
10672             ret = RFAILED;
10673             break;
10674          }
10675          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10676          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10677
10678          if(drbModCfg != NULLP)
10679          {
10680             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
10681             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
10682             if(lcId < MIN_DRB_LCID)
10683             {
10684                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
10685                break;
10686             }
10687             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
10688             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10689             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10690             if(ret == RFAILED)
10691             {
10692                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
10693                break;
10694             }
10695
10696          }
10697          else
10698          {
10699             lcId = getDrbLcId(drbBitMap);
10700             if(lcId == RFAILED)
10701             {
10702                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
10703                ret = RFAILED;
10704                break;
10705             }
10706             if(drbCfg != NULL)
10707             {
10708                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10709                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10710                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10711                if(ret == RFAILED)
10712                {
10713                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
10714                   break;
10715                }
10716             }
10717             else if(drbSetupModCfg != NULL)
10718             {
10719                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10720                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
10721                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10722                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10723                if(ret == RFAILED)
10724                {
10725                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
10726                   break;
10727                }
10728                ueCfgDb->numDrbSetupMod++;
10729             }
10730          }
10731          ueCfgDb->numRlcLcs++;
10732          ueCfgDb->numMacLcs++;
10733          ueCfgDb->numDrb++;
10734
10735          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10736                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10737          if(ret == RFAILED)
10738          {
10739             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
10740             break;
10741          }
10742       }
10743    }
10744    else
10745       ret = RFAILED;
10746
10747    return ret;
10748 }
10749
10750 /*******************************************************************
10751  *
10752  * @brief Function to extract Dl RRC Msg received from CU
10753  *
10754  * @details
10755  *
10756  *    Function : extractDlRrcMsg
10757  *
10758  *    Functionality: Function to extract Dl RRC Msg received from CU
10759  *
10760  * @params[in] F1AP message
10761  * @return ROK     - success
10762  *         RFAILED - failure
10763  *
10764  * ****************************************************************/
10765
10766 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10767    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10768 {
10769    uint8_t ret = ROK;
10770    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10771    if(dlRrcMsg->rrcMsgSize > 0)
10772    {
10773       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10774       if(!dlRrcMsg->rrcMsgPdu)
10775       {
10776          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10777          ret = RFAILED;
10778       }
10779       else
10780       {
10781          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10782          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10783          dlRrcMsg->srbId = SRB1_LCID;
10784          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10785       }
10786    }
10787    return ret;
10788 }
10789
10790 /*******************************************************************
10791  *
10792  * @brief Extract UE capability info
10793  *
10794  * @details
10795  *
10796  *    Function : extractUeCapability
10797  *
10798  *    Functionality: Extract UE capability info and stores in ue Cb
10799  *
10800  * @params[in] Octet string of UE capability RAT container list
10801  * @return ROK     - success
10802  *         RFAILED - failure
10803  *
10804  * ****************************************************************/
10805 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10806 {
10807    uint8_t  idx;
10808    uint16_t recvBufLen;
10809    asn_dec_rval_t rval;
10810    UE_NR_Capability_t  *ueNrCap = NULLP;
10811    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10812
10813    /* Decoding UE Capability RAT Container List */
10814    recvBufLen = ueCapablityListBuf->size;
10815    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10816    if(!ueCapRatContList)
10817    {
10818       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10819       return NULLP;
10820    }
10821    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10822    memset(&rval, 0, sizeof(asn_dec_rval_t));
10823    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10824           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10825    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10826    {
10827       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10828       return NULLP;
10829    }
10830    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10831
10832    /* Free encoded buffer after decoding */
10833
10834    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10835    {
10836       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10837       {
10838          /* Decoding UE NR Capability */
10839           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10840           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10841           if(!ueNrCap)
10842           {
10843              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10844              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10845              return NULLP;
10846           }
10847           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10848           memset(&rval, 0, sizeof(asn_dec_rval_t));
10849           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10850                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10851           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10852           {
10853              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10854              return NULLP;
10855           }
10856           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10857
10858           /* Free encoded buffer after decoding */
10859           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10860       }
10861       free(ueCapRatContList->list.array[idx]);
10862    }
10863
10864    /* Free Memory*/
10865    free(ueCapRatContList->list.array);
10866    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10867    return ueNrCap;
10868 }
10869
10870 /*******************************************************************
10871 *
10872 * @brief free UE context setup request from CU
10873 *
10874 * @details
10875 *
10876 *    Function : freeAperDecodeF1UeContextSetupReq
10877 *
10878 *    Functionality: freeing part for the memory allocated by aper_decoder
10879 *
10880 * @params[in] F1AP message
10881 * @return ROK     - success
10882 *         RFAILED - failure
10883 *
10884 * ****************************************************************/
10885 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10886 {
10887    uint8_t ieIdx = 0;
10888
10889    if(ueSetReq->protocolIEs.list.array != NULLP)
10890    {
10891       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10892       {
10893          if(ueSetReq->protocolIEs.list.array[ieIdx])
10894          {
10895             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10896             {
10897                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10898                   break;
10899                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10900                   break;
10901                case ProtocolIE_ID_id_SpCell_ID:
10902                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10903                   break;
10904                case ProtocolIE_ID_id_ServCellIndex:
10905                   break;
10906                case ProtocolIE_ID_id_SpCellULConfigured:
10907                   break;
10908                case ProtocolIE_ID_id_CUtoDURRCInformation:
10909
10910                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10911                   break;
10912                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10913
10914                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10915                   break;
10916                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10917
10918                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10919                   break;
10920                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10921
10922                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10923                   break;
10924                case ProtocolIE_ID_id_RRCContainer:
10925                   {
10926
10927                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10928                      {
10929
10930                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10931                      }
10932                      break;
10933                   }
10934                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10935                   break;
10936                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10937                   {
10938                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10939                      {
10940                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10941                      }
10942                      break;
10943                   }
10944                default:
10945                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10946             }
10947             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10948          }
10949       }
10950       free(ueSetReq->protocolIEs.list.array);
10951    }
10952 }
10953 /*******************************************************************
10954  *
10955  * @brief Process UE context setup request from CU
10956  *
10957  * @details
10958  *
10959  *    Function : procF1UeContextSetupReq
10960  *
10961  *    Functionality: Process UE context setup request from CU
10962  *
10963  * @params[in] F1AP message
10964  * @return ROK     - success
10965  *         RFAILED - failure
10966  *
10967  * ****************************************************************/
10968 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10969 {
10970    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10971    bool ueCbFound = false;
10972    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10973    DuUeCb   *duUeCb = NULL;
10974    UEContextSetupRequest_t   *ueSetReq = NULL;
10975    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10976
10977    ret = ROK;
10978
10979    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10980    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10981    {
10982       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10983       {
10984          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10985             {
10986                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10987                break;
10988             }
10989          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10990             {
10991                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10992                break;
10993             }
10994          case ProtocolIE_ID_id_ServCellIndex:
10995             {
10996                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10997                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10998                {
10999                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
11000                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
11001                   {
11002                      ueCbFound = true;
11003                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
11004                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
11005                      if(duUeCb->f1UeDb)
11006                      {
11007                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
11008                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
11009                         duUeCb->f1UeDb->cellIdx = cellIdx;
11010                      }
11011                      else
11012                      {
11013                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
11014                         ret = RFAILED;
11015                      }
11016                      break;
11017                   }
11018                   else
11019                      ueCbFound = false;
11020
11021                }
11022                if(!ueCbFound)
11023                {
11024                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
11025                   ret = RFAILED;
11026                }
11027                break;
11028             }
11029          case ProtocolIE_ID_id_SpCellULConfigured:
11030             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
11031                UL, SUL or UL+SUL for the indicated cell for the UE */
11032             break;
11033          case ProtocolIE_ID_id_CUtoDURRCInformation:
11034             {
11035                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
11036                {
11037                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
11038                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
11039                   uE_CapabilityRAT_ContainerList, duUeCb);
11040                }
11041                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
11042                {
11043                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
11044                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
11045                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
11046                   {
11047                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
11048                      //TODO: Update the failure cause in ue context Setup Response
11049                      ret = RFAILED;
11050                   }
11051                }
11052                break;
11053             }
11054          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
11055             {
11056                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
11057                break;
11058             }
11059          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
11060             {
11061                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
11062                &duUeCb->f1UeDb->duUeCfg))
11063                {
11064                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
11065                   //TODO: Update the failure cause in ue context Setup Response
11066                   ret = RFAILED;
11067                }
11068                break;
11069             }
11070          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
11071             {
11072                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
11073
11074                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
11075                   {
11076                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
11077                      //TODO: Update the failure cause in ue context Setup Response
11078                      ret = RFAILED;
11079                   }
11080                break;
11081             }
11082          case ProtocolIE_ID_id_RRCContainer:
11083             {
11084                /* Filling Dl RRC Msg Info */
11085                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
11086                if(!duUeCb->f1UeDb->dlRrcMsg)
11087                {
11088                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
11089                   ret = RFAILED;
11090                }
11091                else
11092                {
11093                   duUeCb->f1UeDb->dlRrcMsgPres = true;
11094                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
11095                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
11096                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
11097                }
11098                break;
11099             }
11100          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11101             {
11102                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
11103                {
11104                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
11105                }
11106                else
11107                {
11108                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
11109                }
11110                break;
11111             }
11112          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
11113             {
11114                /* MaximumBitRate Uplink */
11115                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
11116                if(bitRateSize > 0)
11117                {
11118                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
11119                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
11120                   {
11121                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
11122                      ret = RFAILED;
11123                   }
11124                   else
11125                   {
11126                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
11127                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
11128                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
11129                   }
11130                }
11131                else
11132                   ret = RFAILED;
11133                break;
11134             }
11135          default:
11136             {
11137                break;
11138             }
11139       }
11140    }
11141    if(ret == RFAILED)
11142    {
11143       /*TODO : Negative case*/
11144       // BuildAndSendUeContextSetupRsp(cellId,ueId);
11145       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
11146    }
11147    else
11148       ret = duProcUeContextSetupRequest(duUeCb);
11149
11150    freeAperDecodeF1UeContextSetupReq(ueSetReq);
11151    return ret;
11152
11153 }
11154 /*******************************************************************
11155  * @brief Free the memory allocated for Dl Tunnel Info
11156  *
11157  * @details
11158  *
11159  *    Function : freeDlTnlInfo
11160  *
11161  *    Functionality:
11162  *       Free the memory allocated for Dl Tunnel Info
11163  *
11164  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
11165  * @return void
11166  *
11167  * ****************************************************************/
11168
11169 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
11170 {
11171    uint8_t arrIdx = 0;
11172
11173    if(tnlInfo)
11174    {
11175       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
11176       {
11177          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
11178                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
11179          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
11180                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
11181          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
11182          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
11183       }
11184       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
11185    }
11186 }
11187
11188 /*******************************************************************
11189  * @brief Free the memory allocated for DRB setup List
11190  *
11191  * @details
11192  *
11193  *    Function : freeDrbSetupList
11194  *
11195  *    Functionality:
11196  *       Free the memory allocated for DRB setup list
11197  *
11198  * @params[in] DRBs_Setup_List_t *
11199  * @return void
11200  *
11201  * ****************************************************************/
11202 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
11203 {
11204    uint8_t arrIdx = 0;
11205    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
11206
11207    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11208    {
11209       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11210       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
11211       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
11212    }
11213    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
11214 }
11215
11216 /*******************************************************************
11217  * @brief Free the memory allocated for UE Setup response
11218  *
11219  * @details
11220  *
11221  *    Function : FreeUeContextSetupRsp
11222  *
11223  *    Functionality:
11224  *       Free the memory allocated for UE Setup response
11225  *
11226  * @params[in] F1AP PDU for UE setup response
11227  * @return ROK     - success
11228  *         RFAILED - failure
11229  *
11230  * ****************************************************************/
11231 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
11232 {
11233    uint8_t idx;
11234    UEContextSetupResponse_t *ueSetRsp = NULLP;
11235
11236    if(f1apMsg)
11237    {
11238       if(f1apMsg->choice.successfulOutcome)
11239       {
11240          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
11241                     UEContextSetupResponse;
11242          if(ueSetRsp->protocolIEs.list.array)
11243          {
11244             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
11245             {
11246                if(ueSetRsp->protocolIEs.list.array[idx])
11247                {
11248                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
11249                   {
11250                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11251                         break;
11252                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11253                         break;
11254                      case ProtocolIE_ID_id_DUtoCURRCInformation:
11255                         {
11256                            CellGroupConfig_t *cellGrpCfg = NULLP;
11257                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
11258                                          DUtoCURRCInformation.cellGroupConfig;
11259                            if(cellGrpCfg->buf != NULLP)
11260                            {
11261                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
11262                               cellGrpCfg = NULLP;
11263                            }
11264                            break;
11265                         }
11266                     case ProtocolIE_ID_id_DRBs_Setup_List:
11267                         {
11268                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
11269                            break;
11270                         }
11271                      default:
11272                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
11273                         ueSetRsp->protocolIEs.list.array[idx]->id);
11274                         break;
11275                   }
11276                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
11277                         sizeof(UEContextSetupResponseIEs_t));
11278                }
11279             }
11280             DU_FREE(ueSetRsp->protocolIEs.list.array, \
11281                   ueSetRsp->protocolIEs.list.size);
11282          }
11283          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11284       }
11285       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11286    }
11287 }
11288
11289 /*******************************************************************
11290  *
11291  * @brief Builds Ue context Setup Rsp DU To CU Info
11292  *
11293  * @details
11294  *
11295  *    Function : EncodeUeCntxtDuToCuInfo
11296  *
11297  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
11298  *
11299  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
11300  *
11301  * @return ROK     - success
11302  *         RFAILED - failure
11303  *
11304  ******************************************************************/
11305
11306 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
11307 {
11308    asn_enc_rval_t        encRetVal;
11309
11310    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
11311    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11312    encBufSize = 0;
11313    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
11314    /* Encode results */
11315    if(encRetVal.encoded == ENCODE_FAIL)
11316    {
11317       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
11318             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11319       return RFAILED;
11320    }
11321    else
11322    {
11323       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
11324       for(int i=0; i< encBufSize; i++)
11325       {
11326          printf("%x",encBuf[i]);
11327       }
11328    }
11329    duToCuCellGrp->size = encBufSize;
11330    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
11331    if(!duToCuCellGrp->buf)
11332    {
11333       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
11334    }
11335    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
11336    return ROK;
11337 }
11338
11339 /*******************************************************************
11340  *
11341  * @brief Fills Dl Gtp tunnel Info
11342  *
11343  * @details
11344  *
11345  *    Function : fillGtpTunnelforDl
11346  *
11347  *    Functionality: Fills Dl Gtp tunnel Info
11348  *
11349  * @params[in]
11350  *
11351  * @return ROK     - success
11352  *         RFAILED - failure
11353  *
11354  * ****************************************************************/
11355
11356 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
11357 {
11358    uint8_t bufSize = 0;
11359
11360    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
11361    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
11362    if(gtpDl->transportLayerAddress.buf == NULLP)
11363    {
11364       return RFAILED;
11365    }
11366    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
11367
11368    /*GTP TEID*/
11369    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
11370    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
11371    if(gtpDl->gTP_TEID.buf == NULLP)
11372    {
11373       return RFAILED;
11374    }
11375    bufSize = 3; /*forming an Octect String*/
11376    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
11377
11378    return ROK;
11379 }
11380
11381 /*******************************************************************
11382  *
11383  * @brief Fills DL Tunnel Setup List
11384  *
11385  * @details
11386  *
11387  *    Function : fillDlTnlSetupList
11388  *
11389  *    Functionality: Fills the DL Tunnel Setup List
11390  *
11391  * @params[in]
11392  *
11393  * @return ROK     - success
11394  *         RFAILED - failure
11395  *
11396  * ****************************************************************/
11397
11398 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
11399 {
11400    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
11401
11402    eleCount = 1;
11403    dlTnlInfo->list.count = eleCount;
11404    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
11405
11406    /* Initialize the DL Tnl Setup List Members */
11407    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
11408    if(dlTnlInfo->list.array == NULLP)
11409    {
11410       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
11411       ret = RFAILED;
11412    }
11413    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
11414    {
11415       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
11416       if(dlTnlInfo->list.array[arrIdx] == NULLP)
11417       {
11418          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
11419          return RFAILED;
11420       }
11421       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
11422       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
11423       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
11424       {
11425          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
11426          return RFAILED;
11427       }
11428       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
11429                tnlCfg->tnlCfg1);
11430       if(ret != ROK)
11431          break;
11432    }
11433    return ret;
11434 }
11435
11436 /*******************************************************************
11437  *
11438  * @brief Fills the Drb Setup List for Ue Context Setup Response
11439  *
11440  * @details
11441  *
11442  *    Function : fillDrbSetupList
11443  *
11444  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
11445  *
11446  * @params[in]
11447  *
11448  * @return ROK     - success
11449  *         RFAILED - failure
11450  *
11451  * ****************************************************************/
11452 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
11453 {
11454    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
11455    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
11456
11457    eleCount = ueCfg->numDrb;
11458    drbSetupList->list.count = eleCount;
11459    drbSetupList->list.size = \
11460         (eleCount * sizeof(DRBs_Setup_Item_t *));
11461
11462    /* Initialize the Drb Setup List Members */
11463    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
11464    if(drbSetupList->list.array == NULLP)
11465    {
11466       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
11467       ret = RFAILED;
11468    }
11469
11470    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
11471    {
11472       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
11473       if(drbSetupList->list.array[arrIdx] == NULLP)
11474       {
11475          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
11476          return RFAILED;
11477       }
11478       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11479       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
11480       drbItemIe->criticality = Criticality_reject;
11481       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
11482       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11483       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
11484           &ueCfg->upTnlInfo[arrIdx]);
11485       if(ret != ROK)
11486          break;
11487    }
11488    return ret;
11489 }
11490
11491 /*******************************************************************
11492  *
11493  * @brief Builds and sends the UE Setup Response
11494  *
11495  * @details
11496  *
11497  *    Function : BuildAndSendUeContextSetupRsp
11498  *
11499  *    Functionality: Constructs the UE Setup Response and sends
11500  *                   it to the DU through SCTP.
11501  *
11502  * @params[in] uint8_t cellId,uint8_t ueId
11503  *
11504  * @return ROK     - success
11505  *         RFAILED - failure
11506  *
11507  * ****************************************************************/
11508 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
11509 {
11510    uint8_t   idx, ret, cellIdx, elementCnt;
11511    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11512    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11513    asn_enc_rval_t  encRetVal;        /* Encoder return value */
11514    F1AP_PDU_t               *f1apMsg = NULLP;
11515    UEContextSetupResponse_t *ueSetRsp = NULLP;
11516    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
11517    DuUeCb                   *ueCb = NULLP;
11518
11519    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
11520
11521    while(true)
11522    {
11523       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11524       if(f1apMsg == NULLP)
11525       {
11526          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11527          ret = RFAILED;
11528          break;
11529       }
11530
11531       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
11532       DU_ALLOC(f1apMsg->choice.successfulOutcome,
11533             sizeof(SuccessfulOutcome_t));
11534       if(f1apMsg->choice.successfulOutcome == NULLP)
11535       {
11536          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
11537          ret = RFAILED;
11538          break;
11539       }
11540
11541       f1apMsg->choice.successfulOutcome->procedureCode = \
11542                                                          ProcedureCode_id_UEContextSetup;
11543       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11544       f1apMsg->choice.successfulOutcome->value.present = \
11545                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
11546
11547       ueSetRsp =
11548          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
11549       elementCnt = 4;
11550       ueSetRsp->protocolIEs.list.count = elementCnt;
11551       ueSetRsp->protocolIEs.list.size = \
11552                                         elementCnt * sizeof(UEContextSetupResponse_t *);
11553
11554       /* Initialize the UESetup members */
11555       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
11556             ueSetRsp->protocolIEs.list.size);
11557       if(ueSetRsp->protocolIEs.list.array == NULLP)
11558       {
11559          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11560          ret = RFAILED;
11561          break;
11562       }
11563
11564       for(idx=0; idx<elementCnt; idx++)
11565       {
11566          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
11567                sizeof(UEContextSetupResponseIEs_t));
11568          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
11569          {
11570             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11571             ret = RFAILED;
11572             break;
11573          }
11574       }
11575       /* Fetching Ue Cb Info*/
11576       GET_CELL_IDX(cellId, cellIdx);
11577       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
11578       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
11579       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
11580
11581       idx = 0;
11582       /*GNB CU UE F1AP ID*/
11583       ueSetRsp->protocolIEs.list.array[idx]->id = \
11584                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11585       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11586       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11587                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11588       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11589
11590       /*GNB DU UE F1AP ID*/
11591       idx++;
11592       ueSetRsp->protocolIEs.list.array[idx]->id = \
11593                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11594       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11595       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11596                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11597       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11598
11599
11600       /*DUtoCURRC Information */
11601       idx++;
11602       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11603                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11604       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11605       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11606                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11607       if(ueCb->f1UeDb)
11608       {
11609          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11610          {
11611             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11612             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11613                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11614             if(ret == RFAILED)
11615             {
11616                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11617                freeF1UeDb(ueCb->f1UeDb);
11618                ueCb->f1UeDb = NULLP;
11619                break;
11620             }
11621          }
11622       }
11623       else
11624       {
11625          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11626          ret = RFAILED;
11627          break;
11628       }
11629
11630       /* Drb Setup List */
11631       idx++;
11632       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11633                                  ProtocolIE_ID_id_DRBs_Setup_List;
11634       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11635       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11636                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11637       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11638                &ueCb->f1UeDb->duUeCfg);
11639       if(ret == RFAILED)
11640       {
11641          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11642          freeF1UeDb(ueCb->f1UeDb);
11643          ueCb->f1UeDb = NULLP;
11644          break;
11645       }
11646
11647        /* Free UeContext Db created during Ue context Req */
11648        freeF1UeDb(ueCb->f1UeDb);
11649        ueCb->f1UeDb = NULLP;
11650
11651       /* TODO: To send Drb list */
11652       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11653
11654       /* Encode the UE context setup response type as APER */
11655       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11656       encBufSize = 0;
11657       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11658             encBuf);
11659       /* Encode results */
11660       if(encRetVal.encoded == ENCODE_FAIL)
11661       {
11662          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11663                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11664          ret = RFAILED;
11665          break;
11666       }
11667       else
11668       {
11669          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11670          for(int i=0; i< encBufSize; i++)
11671          {
11672             printf("%x",encBuf[i]);
11673          }
11674       }
11675
11676       /* Sending  msg  */
11677       if(sendF1APMsg()  != ROK)
11678       {
11679          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11680          ret = RFAILED;
11681          break;
11682       }
11683       break;
11684    }
11685    FreeUeContextSetupRsp(f1apMsg);
11686    return ret;
11687 }/* End of BuildAndSendUeContextSetupRsp */
11688 /*******************************************************************
11689 *
11690 * @brief  Build And Send Ue Context Rsp
11691 *
11692 * @details
11693 *
11694 *    Function : BuildAndSendUeCtxtRsp
11695 *
11696 *    Functionality : Build And Send Ue Context Rsp
11697
11698 * @params[in]
11699 * @return sucess = ROK
11700 *         failure = RFAILED
11701 *
11702 * ****************************************************************/
11703 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
11704 {
11705    uint8_t cellIdx = 0, actionType = 0;
11706
11707    GET_CELL_IDX(cellId, cellIdx);
11708    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
11709
11710    switch(actionType)
11711    {
11712       case UE_CTXT_SETUP:
11713          {
11714             BuildAndSendUeContextSetupRsp(cellId,ueId);
11715             break;
11716          }
11717       case UE_CTXT_MOD:
11718          {
11719             BuildAndSendUeContextModRsp(cellId, ueId);
11720             break;
11721          }
11722       default:
11723          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11724          break;
11725
11726    }
11727    return ROK;
11728 }
11729
11730 /*******************************************************************
11731  *
11732  * @brief deallocating the memory of  F1reset msg
11733  *
11734  * @details
11735  *
11736  *    Function : FreeF1ResetReq
11737  *
11738  *    Functionality :
11739  *         - freeing memory of F1reset request msg
11740  *
11741  * @params[in]
11742  * @return void
11743  *
11744  *
11745  * ****************************************************************/
11746 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11747 {
11748    uint8_t idx =0 ;
11749    Reset_t *f1ResetMsg;
11750
11751    if(f1apMsg)
11752    {
11753       if(f1apMsg->choice.initiatingMessage)
11754       {
11755          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11756
11757          if(f1ResetMsg->protocolIEs.list.array)
11758          {
11759             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11760             {
11761                if(f1ResetMsg->protocolIEs.list.array[idx])
11762                {
11763                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11764                }
11765             }
11766             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11767          }
11768          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11769       }
11770       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11771    }
11772 }
11773 /*******************************************************************
11774  *
11775  * @brief Build and Send F1reset request
11776  *
11777  * @details
11778  *
11779  *    Function : BuildAndSendF1ResetReq
11780  *
11781  *    Functionality:
11782  *         - Build and Send F1reset request msg
11783  *
11784  * @params[in]
11785  * @return ROK     - success
11786  *         RFAILED - failure
11787  *
11788  * ****************************************************************/
11789 uint8_t BuildAndSendF1ResetReq()
11790 {
11791    uint8_t          elementCnt=0;
11792    uint8_t          idx=0;
11793    uint8_t          ret= RFAILED;
11794    Reset_t          *f1ResetMsg = NULLP;
11795    F1AP_PDU_t       *f1apMsg = NULLP;
11796    asn_enc_rval_t   encRetVal;
11797    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11798    do
11799    {
11800       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11801       if(f1apMsg == NULLP)
11802       {
11803          break;
11804       }
11805       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11806       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11807       if(f1apMsg->choice.initiatingMessage == NULLP)
11808       {
11809          break;
11810       }
11811       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11812       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11813       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11814
11815       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11816
11817       elementCnt = 3;
11818       f1ResetMsg->protocolIEs.list.count = elementCnt;
11819       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11820
11821       /* Initialize the F1Setup members */
11822       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11823       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11824       {
11825          break;
11826       }
11827       for(idx=0; idx<elementCnt; idx++)
11828       {
11829          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11830          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11831          {
11832             break;
11833          }
11834       }
11835
11836       /*TransactionID*/
11837       idx=0;
11838       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11839       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11840       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11841       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11842
11843       /*Cause*/
11844       idx++;
11845       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11846       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11847       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11848       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11849       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11850
11851       /*Reset Type*/
11852       idx++;
11853       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11854       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11855       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11856       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11857       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11858
11859       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11860
11861       /* Encode the F1SetupRequest type as APER */
11862       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11863       encBufSize = 0;
11864       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11865             encBuf);
11866
11867       /* Encode results */
11868       if(encRetVal.encoded == ENCODE_FAIL)
11869       {
11870          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11871                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11872          break;
11873       }
11874       else
11875       {
11876          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11877          for(idx=0; idx< encBufSize; idx++)
11878          {
11879             printf("%x",encBuf[idx]);
11880          }
11881       }
11882
11883       if(sendF1APMsg() != ROK)
11884       {
11885          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11886          break;
11887       }
11888
11889       ret = ROK;
11890       break;
11891    }while(true);
11892
11893    FreeF1ResetReq(f1apMsg);
11894    return ret;
11895 }
11896 /*******************************************************************
11897  *
11898  * @brief Build And Send F1ResetAck
11899  *
11900  * @details
11901  *
11902  *    Function : BuildAndSendF1ResetAck
11903  *
11904  *    Functionality:
11905  *         - Build And Send  F1ResetRSP
11906  *
11907  * @return ROK     - success
11908  *         RFAILED - failure
11909  *
11910  * ****************************************************************/
11911 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11912 {
11913    uint8_t idx;
11914    ResetAcknowledge_t *f1ResetAck;
11915
11916    if(f1apMsg)
11917    {
11918       if(f1apMsg->choice.successfulOutcome)
11919       {
11920          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11921
11922          if(f1ResetAck->protocolIEs.list.array)
11923          {
11924             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11925             {
11926                if(f1ResetAck->protocolIEs.list.array[idx])
11927                {
11928                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11929                }
11930             }
11931             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11932          }
11933          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11934       }
11935       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11936    }
11937 }
11938
11939 /*******************************************************************
11940  *
11941  * @brief Build And Send F1ResetAck
11942  *
11943  * @details
11944  *
11945  *    Function : BuildAndSendF1ResetAck
11946  *
11947  *    Functionality:
11948  *         - Build And Send  F1ResetRSP
11949  *
11950  *  @params[in]
11951  * @return ROK     - success
11952  *         RFAILED - failure
11953  *
11954  * ****************************************************************/
11955 uint8_t BuildAndSendF1ResetAck()
11956 {
11957    uint8_t                idx = 0;
11958    uint8_t                elementCnt = 0;
11959    uint8_t                ret = RFAILED;
11960    F1AP_PDU_t             *f1apMsg = NULL;
11961    ResetAcknowledge_t     *f1ResetAck = NULLP;
11962    asn_enc_rval_t         encRetVal;
11963    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11964
11965    do{
11966       /* Allocate the memory for F1ResetRequest_t */
11967       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11968       if(f1apMsg == NULLP)
11969       {
11970          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11971          break;
11972       }
11973
11974       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11975
11976       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11977       if(f1apMsg->choice.successfulOutcome == NULLP)
11978       {
11979          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11980          break;
11981       }
11982       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11983       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11984       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11985
11986       elementCnt = 1;
11987
11988       f1ResetAck->protocolIEs.list.count = elementCnt;
11989       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11990
11991       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11992       if(f1ResetAck->protocolIEs.list.array == NULLP)
11993       {
11994          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11995          break;
11996       }
11997
11998       for(idx=0; idx<elementCnt; idx++)
11999       {
12000          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
12001          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
12002          {
12003             break;
12004          }
12005       }
12006       /*TransactionID*/
12007       idx = 0;
12008       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
12009       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12010       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
12011       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
12012
12013       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12014
12015       /* Encode the F1SetupRequest type as UPER */
12016       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12017       encBufSize = 0;
12018       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
12019
12020       /* Check encode results */
12021       if(encRetVal.encoded == ENCODE_FAIL)
12022       {
12023          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
12024                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12025          break;
12026       }
12027       else
12028       {
12029          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
12030          for(int i=0; i< encBufSize; i++)
12031          {
12032             printf("%x",encBuf[i]);
12033          }
12034       }
12035       /* Sending msg */
12036       if(sendF1APMsg() != ROK)
12037       {
12038          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
12039          break;
12040       }
12041
12042       ret = ROK;
12043       break;
12044    }while(true);
12045
12046    FreeF1ResetAck(f1apMsg);
12047    return ret;
12048 }
12049 /******************************************************************
12050 *
12051 * @brief free F1 reset msg allocated by aper_decoder
12052 *
12053 * @details
12054 *
12055 *    Function : freeAperDecodeF1ResetMsg
12056 *
12057 *    Functionality: free F1 reset msg allocated by aper_decoder
12058 *
12059 * @params[in] Reset_t *f1ResetMsg
12060 * @return void
12061 *
12062 * ****************************************************************/
12063
12064 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
12065 {
12066    uint8_t ieIdx =0;
12067    if(f1ResetMsg->protocolIEs.list.array)
12068    {
12069       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
12070       {
12071          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
12072          {
12073             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
12074          }
12075       }
12076       free(f1ResetMsg->protocolIEs.list.array);
12077    }
12078 }
12079
12080 /******************************************************************
12081  *
12082  * @brief Processes DL RRC Message Transfer  sent by CU
12083  *
12084  * @details
12085  *
12086  *    Function : procF1ResetReq
12087  *
12088  *    Functionality: Processes DL RRC Message Transfer sent by CU
12089  *
12090  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12091  * @return ROK     - success
12092  *         RFAILED - failure
12093  *
12094  * ****************************************************************/
12095 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
12096 {
12097    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
12098    uint8_t       ieIdx = 0;
12099    uint8_t        ret = ROK;
12100    Reset_t       *f1ResetMsg = NULLP;
12101
12102    DU_LOG("\nINFO   -->  Processing F1 reset request");
12103    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
12104
12105    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
12106    {
12107       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
12108       {
12109          case ProtocolIE_ID_id_TransactionID:
12110             break;
12111
12112          case ProtocolIE_ID_id_Cause:
12113             break;
12114
12115          case ProtocolIE_ID_id_ResetType:
12116             {
12117                break;
12118             }
12119
12120          default:
12121             break;
12122       }
12123    }
12124    ret = BuildAndSendF1ResetAck();
12125    DU_LOG("\nINFO   -->  UE release is not supported for now");
12126
12127    freeAperDecodeF1ResetMsg(f1ResetMsg);
12128
12129    return ret;
12130 }
12131
12132 /*******************************************************************
12133  *
12134  * @brief free the RRC delivery report
12135  *
12136  * @details
12137  *
12138  *    Function : freeRrcDeliveryReport
12139  *
12140  *    Functionality: free the RRC delivery report
12141  *
12142  * @params[in]
12143  * @return ROK     - success
12144  *         RFAILED - failure
12145  *
12146  * ****************************************************************/
12147 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
12148 {
12149    uint8_t idx=0;
12150    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
12151
12152    if(f1apMsg)
12153    {
12154       if(f1apMsg->choice.initiatingMessage)
12155       {
12156          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
12157          if(rrcDeliveryReport->protocolIEs.list.array)
12158          {
12159             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
12160                   idx++)
12161             {
12162                if(rrcDeliveryReport->protocolIEs.list.array[idx])
12163                {
12164                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
12165                         sizeof(RRCDeliveryReportIEs_t));
12166                }
12167             }
12168             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
12169                   rrcDeliveryReport->protocolIEs.list.size);
12170          }
12171          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
12172       }
12173       DU_FREE(f1apMsg,
12174             sizeof(F1AP_PDU_t));
12175    }
12176 }
12177
12178 /*******************************************************************
12179 *
12180 * @brief Builds and sends the RRC delivery report
12181 *
12182 * @details
12183 *
12184 *    Function : BuildAndSendRrcDeliveryReport
12185 *
12186 *    Functionality: Builds and sends the RRC delivery report
12187 *
12188 * @params[in]
12189 *
12190 * @return ROK     - success
12191 *         RFAILED - failure
12192 *
12193 * ****************************************************************/
12194 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
12195    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
12196 {
12197    uint8_t             ret = RFAILED;
12198    uint8_t             idx    = 0;
12199    uint8_t             idx1   = 0;
12200    uint8_t             elementCnt = 0;
12201    F1AP_PDU_t          *f1apMsg = NULLP;
12202    asn_enc_rval_t      encRetVal;
12203    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
12204
12205    do{
12206
12207       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
12208       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12209       if(f1apMsg == NULLP)
12210       {
12211          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12212          break;
12213       }
12214       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12215       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
12216       if(f1apMsg->choice.initiatingMessage == NULLP)
12217       {
12218          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
12219          break;
12220       }
12221       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
12222       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
12223       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
12224
12225       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
12226       elementCnt = 4;
12227       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
12228       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
12229
12230       /* Initialize the F1Setup members */
12231       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
12232       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
12233       {
12234          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
12235          break;
12236       }
12237       for(idx =0 ;idx <elementCnt; idx++)
12238       {
12239          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
12240          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
12241          {
12242             break;
12243          }
12244       }
12245
12246       idx1 = 0;
12247
12248       /*GNB CU UE F1AP ID*/
12249       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12250       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
12251       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
12252       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12253
12254       /*GNB DU UE F1AP ID*/
12255       idx1++;
12256       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12257       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
12258       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
12259       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12260
12261       /*RRC delivery status*/
12262       idx1++;
12263       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
12264       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
12265       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
12266       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
12267       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
12268       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
12269       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
12270
12271       /* SRB ID */
12272       idx1++;
12273       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
12274       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
12275       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
12276       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
12277
12278       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12279
12280       /* Encode the RRC DELIVERY REPORT type as APER */
12281       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12282       encBufSize = 0;
12283       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12284             encBuf);
12285
12286       /* Encode results */
12287       if(encRetVal.encoded == ENCODE_FAIL)
12288       {
12289          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
12290                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12291          break;
12292       }
12293       else
12294       {
12295          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
12296          for(idx=0; idx< encBufSize; idx++)
12297          {
12298             printf("%x",encBuf[idx]);
12299          }
12300       }
12301
12302       /* Sending msg */
12303       if(sendF1APMsg() != ROK)
12304       {
12305          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
12306          break;
12307       }
12308       ret = ROK;
12309       break;
12310
12311    }while(true);
12312
12313    freeRrcDeliveryReport(f1apMsg);
12314    return ret;
12315 }
12316
12317 /*******************************************************************
12318  *
12319  * @brief Processes cells to be activated
12320  *
12321  * @details
12322  *
12323  *    Function : extractCellsToBeActivated
12324  *
12325  *    Functionality:
12326  *      - Processes cells to be activated list received in F1SetupRsp
12327  *
12328  * @params[in] void
12329  * @return ROK     - success
12330  *         RFAILED - failure
12331  *
12332  * ****************************************************************/
12333
12334 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
12335 {
12336    uint8_t  ret = ROK;
12337    uint16_t idx, nci, pci = 0;
12338    Cells_to_be_Activated_List_Item_t cell;
12339
12340    for(idx=0; idx<cellsToActivate.list.count; idx++)
12341    {
12342       nci = 0;
12343       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
12344       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
12345
12346       if(cell.nRPCI)
12347       {
12348          pci = *cell.nRPCI;
12349       }
12350       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
12351    }
12352    return ret;
12353 }
12354 /******************************************************************
12355 *
12356 * @brief Processes F1 Setup Response allocated by aper_decoder
12357 *
12358 * @details
12359 *
12360 *    Function : freeF1SetupRsp
12361 *
12362 *    Functionality: free F1 Setup Response allocated by aper_decoder
12363 *
12364 * @params[in] F1SetupResponse_t *f1SetRspMsg
12365 * @return void
12366 *
12367 * ****************************************************************/
12368
12369 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
12370 {
12371    uint8_t ieIdx =0;
12372    uint8_t arrIdx =0;
12373    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
12374    RRC_Version_t      *rrcVer =NULLP;
12375
12376    if(f1SetRspMsg->protocolIEs.list.array)
12377    {
12378       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
12379       {
12380          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
12381          {
12382             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
12383             {
12384                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12385                   {
12386                      cellToActivate =
12387                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
12388                      if(cellToActivate->list.array)
12389                      {
12390                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
12391                         {
12392                            if(cellToActivate->list.array[arrIdx])
12393                            {
12394
12395                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
12396                               pLMN_Identity.buf)
12397                               {
12398                                  if(cellToActivate->list.array[0]->value.choice.\
12399                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
12400                                  {
12401                                     free(cellToActivate->list.array[0]->value.choice.\
12402                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
12403                                  }
12404
12405                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
12406                                        nRCGI.pLMN_Identity.buf);
12407                               }
12408                               free(cellToActivate->list.array[arrIdx]);
12409                            }
12410                         }
12411                         free(cellToActivate->list.array);
12412                      }
12413                      break;
12414                   }
12415                case ProtocolIE_ID_id_TransactionID:
12416                   {
12417                      break;
12418                   }
12419                case ProtocolIE_ID_id_gNB_CU_Name:
12420                   {
12421                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
12422                      break;
12423                   }
12424                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12425                   {
12426                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
12427                      if(rrcVer->latest_RRC_Version.buf)
12428                      {
12429                         if(rrcVer->iE_Extensions)
12430                         {
12431                            if(rrcVer->iE_Extensions->list.array)
12432                            {
12433                               if(rrcVer->iE_Extensions->list.array[0])
12434                               {
12435                                  if(rrcVer->iE_Extensions->list.\
12436                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
12437                                  {
12438                                     free(rrcVer->iE_Extensions->list.\
12439                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
12440                                  }
12441                                  free(rrcVer->iE_Extensions->list.array[0]);
12442                               }
12443                               free(rrcVer->iE_Extensions->list.array);
12444                            }
12445                            free(rrcVer->iE_Extensions);
12446                         }
12447                         free(rrcVer->latest_RRC_Version.buf);
12448                      }
12449                      break;
12450
12451                   }
12452                default:
12453                   {
12454                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12455                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
12456                   }
12457             }
12458             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
12459          }
12460       }
12461       free(f1SetRspMsg->protocolIEs.list.array);
12462    }
12463 }
12464 /******************************************************************
12465  *
12466  * @brief Processes F1 Setup Response sent by CU
12467  *
12468  * @details
12469  *
12470  *    Function : procF1SetupRsp
12471  *
12472  *    Functionality: Processes F1 Setup Response sent by CU
12473  *
12474  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12475  * @return ROK     - success
12476  *         RFAILED - failure
12477  *
12478  * ****************************************************************/
12479 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
12480 {
12481    uint8_t ret = ROK;
12482    uint16_t idx =0;
12483    F1SetupResponse_t *f1SetRspMsg = NULLP;
12484    GNB_CU_Name_t     *cuName = NULLP;
12485    F1SetupRsp  f1SetRspDb;
12486    RRC_Version_t      *rrcVer =NULLP;
12487
12488    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
12489
12490    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
12491    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
12492
12493    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
12494    {
12495       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
12496       {
12497          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12498             {
12499                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
12500                      value.choice.Cells_to_be_Activated_List);
12501                break;
12502             }
12503          case ProtocolIE_ID_id_TransactionID:
12504             {
12505                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
12506                                     value.choice.TransactionID;
12507                break;
12508             }
12509          case ProtocolIE_ID_id_gNB_CU_Name:
12510             {
12511                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
12512                         value.choice.GNB_CU_Name;
12513                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
12514                break;
12515             }
12516          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12517             {
12518                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
12519                strcpy(f1SetRspDb.rrcVersion.rrcVer,
12520                      (const char*)rrcVer->latest_RRC_Version.buf);
12521                break;
12522             }
12523          default:
12524             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12525                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
12526       }
12527       duProcF1SetupRsp();
12528    }
12529
12530    freeAperDecodeF1SetupRsp(f1SetRspMsg);
12531    return ret;
12532 }
12533 /*******************************************************************
12534 *
12535 * @brief free GNB DU config update ack
12536 *
12537 * @details
12538 *
12539 *    Function : freeAperDecodeGnbDuAck
12540 *
12541 *    Functionality: Processes GNB DU config update ack And
12542 *                     added free part for the memory allocated by aper_decoder
12543 *
12544 * @params[in] F1AP_PDU_t ASN decoded F1AP message
12545 * @return ROK     - success
12546 *         RFAILED - failure
12547 *
12548 * ****************************************************************/
12549
12550 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
12551 {
12552    uint8_t ieIdx = 0;
12553
12554    if(gnbDuAck->protocolIEs.list.array)
12555    {
12556       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12557       {
12558          if(gnbDuAck->protocolIEs.list.array[ieIdx])
12559          {
12560             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
12561          }
12562       }
12563       free(gnbDuAck->protocolIEs.list.array);
12564    }
12565 }
12566
12567 /*******************************************************************
12568 *
12569 * @brief Building  result of gnb-du config update ack output
12570 *
12571 * @details
12572 *
12573 *    Function : duProcGnbDuCfgUpdAckMsg
12574 *
12575 *    Functionality:
12576 *        Building output of gnb-du config update ack
12577 *
12578 * @params[in] transId
12579 * @return void
12580 *
12581 * ****************************************************************/
12582
12583 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
12584 {
12585    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
12586    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
12587    uint16_t cellId =0, cellIdx =0, crnti=0;
12588    CmLList *f1apPduNode = NULLP;
12589    ReservedF1apPduInfo *f1apPduInfo =NULLP;
12590    F1AP_PDU_t *f1apMsgPdu = NULLP;
12591    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
12592    BIT_STRING_t *cellIdentity=NULLP;
12593    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
12594    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
12595    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
12596
12597    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12598    f1apPduNode = searchFromReservedF1apPduList(transId);
12599    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12600    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12601
12602    if(f1apMsgPdu)
12603    {
12604       if(f1apMsgPdu->choice.initiatingMessage)
12605       {
12606          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12607          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12608          {
12609             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12610             {
12611                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12612                   {
12613                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12614                                      Served_Cells_To_Delete_List;
12615                      if(cellsToDelete->list.array)
12616                      {
12617                         if(cellsToDelete->list.array[arrIdx])
12618                         {
12619                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12620                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12621                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12622                            {
12623                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12624                               bitStringToInt(cellIdentity, &cellId);
12625                            }
12626                         }
12627                      }
12628
12629                      GET_CELL_IDX(cellId, cellIdx);
12630                      if(duCb.actvCellLst[cellIdx] != NULLP)
12631                      {
12632                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12633                         {
12634                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12635                            ret = duSendCellDeletReq(cellId);
12636                            if(ret == RFAILED)
12637                            {
12638                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12639                               request for cellId[%d]", cellId);
12640                            }
12641                         }
12642                         else
12643                         {
12644                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
12645                            while(totalActiveUe)
12646                            {
12647                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
12648                               {
12649                                  ueIdx++;
12650                                  continue;
12651                               }
12652
12653                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12654                               GET_UE_ID(crnti,ueId);
12655                               /* Sending Ue Context release request only for maximum supporting UEs */
12656                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12657                               if(ret == RFAILED)
12658                               {
12659                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12660                                  request for cellId[%d]", cellId);
12661                               }
12662                               ueIdx++;
12663                               totalActiveUe--;
12664                            }
12665                         }
12666                      }
12667                      else
12668                      {
12669                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12670                         ret = RFAILED;
12671                      }
12672                      break;
12673                   }
12674
12675                default:
12676                   break;
12677             }
12678          }
12679       }
12680    }
12681
12682    FreeDUConfigUpdate(f1apMsgPdu);
12683    deleteFromReservedF1apPduList(f1apPduNode);
12684    return ret;
12685 }
12686
12687 /*******************************************************************
12688 *
12689 * @brief Processes GNB DU config update ack
12690 *
12691 * @details
12692 *
12693 *    Function : procF1GNBDUCfgUpdAck
12694 *
12695 *    Functionality: added free part for the memory allocated by aper_decoder
12696 *
12697 * @params[in] F1AP_PDU_t *f1apMsg
12698 * @return void
12699 *
12700 * ****************************************************************/
12701 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12702 {
12703    uint8_t ieIdx=0,transId=0;
12704    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12705
12706    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12707    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12708
12709    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12710    {
12711       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12712       {
12713          case ProtocolIE_ID_id_TransactionID:
12714             {
12715                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12716                break;
12717             }
12718          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12719             {
12720                break;
12721             }
12722          default :
12723             {
12724                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12725                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12726                break;
12727             }
12728       }
12729    }
12730
12731    duProcGnbDuCfgUpdAckMsg(transId);
12732
12733 #if 0
12734    /* presently we are not supporting F1 Reset from DU to CU , we are only
12735     * supporting F1 Reset from CU to DU */
12736
12737    if(BuildAndSendF1ResetReq() != ROK)
12738    {
12739       return RFAILED;
12740    }
12741 #endif
12742
12743    freeAperDecodeGnbDuAck(gnbDuAck);
12744    return ROK;
12745 }
12746 /******************************************************************
12747 *
12748 * @brief free DL RRC Message Transfer allocated by aper_decoder
12749 *
12750 * @details
12751 *
12752 *    Function : freeAperDecodef1DlRrcMsg
12753 *
12754 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12755 *
12756 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12757 * @return ROK     - success
12758 *         RFAILED - failure
12759 *
12760 * ****************************************************************/
12761
12762 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12763 {
12764    uint8_t ieIdx =0;
12765    RRCContainer_t *rrcContainer = NULLP;
12766
12767    if(f1DlRrcMsg->protocolIEs.list.array)
12768    {
12769       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12770       {
12771          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12772          {
12773             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12774             {
12775                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12776                   break;
12777                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12778                   break;
12779                case ProtocolIE_ID_id_SRBID:
12780                   break;
12781                case ProtocolIE_ID_id_RRCContainer:
12782                   {
12783                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12784                      free(rrcContainer->buf);
12785                   }
12786                case ProtocolIE_ID_id_ExecuteDuplication:
12787                   break;
12788                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12789                   break;
12790                   break;
12791             }
12792             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12793          }
12794       }
12795       free(f1DlRrcMsg->protocolIEs.list.array);
12796    }
12797 }
12798 /******************************************************************
12799  *
12800  * @brief Processes DL RRC Message Transfer  sent by CU
12801  *
12802  * @details
12803  *
12804  *    Function : procF1DlRrcMsgTrans
12805  *
12806  *    Functionality: Processes DL RRC Message Transfer sent by CU
12807  *
12808  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12809  * @return ROK     - success
12810  *         RFAILED - failure
12811  *
12812  * ****************************************************************/
12813 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12814 {
12815    uint8_t  idx, ret;
12816    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12817    F1DlRrcMsg dlMsg;
12818    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12819
12820    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12821    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12822
12823    ret = ROK;
12824
12825    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12826    {
12827       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12828       {
12829          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12830             {
12831                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12832                break;
12833             }
12834          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12835             {
12836                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12837                break;
12838             }
12839          case ProtocolIE_ID_id_SRBID:
12840             {
12841                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12842                break;
12843             }
12844          case ProtocolIE_ID_id_ExecuteDuplication:
12845             dlMsg.execDup = true;
12846             break;
12847
12848          case ProtocolIE_ID_id_RRCContainer:
12849             {
12850                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12851                {
12852                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12853                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12854                   if(dlMsg.rrcMsgPdu)
12855                   {
12856                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12857                         dlMsg.rrcMsgSize);
12858                   }
12859                   else
12860                   {
12861                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12862                      return RFAILED;
12863                   }
12864                }
12865                else
12866                {
12867                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12868                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12869                   return RFAILED;
12870                }
12871                break;
12872             }
12873          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12874             {
12875                dlMsg.deliveryStatRpt = true;
12876                break;
12877             }
12878          default:
12879             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12880                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12881       }
12882    }
12883
12884    ret = duProcDlRrcMsg(&dlMsg);
12885
12886    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12887    return ret;
12888 }
12889 /*******************************************************************
12890  *
12891 * @brief Builds the DRB to be Setup Mod list
12892 *
12893 * @details
12894 *
12895 *    Function :
12896 *
12897 *    Functionality: Constructs the DRB to be Setup Mod list
12898 *
12899 * @params[in] DRBs_SetupMod_List_t *drbSet
12900 *
12901 * @return ROK     - success
12902 *         RFAILED - failure
12903 *
12904 * ****************************************************************/
12905
12906 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12907 {
12908    uint8_t arrIdx =0;
12909    uint8_t drbCnt =0;
12910    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12911
12912    drbCnt = ueCfg->numDrbSetupMod;
12913    drbSet->list.count = drbCnt;
12914    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12915    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12916    if(drbSet->list.array == NULLP)
12917    {
12918       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12919       return  RFAILED;
12920    }
12921    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12922    {
12923       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12924       if(drbSet->list.array[arrIdx] == NULLP)
12925       {
12926               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12927               return  RFAILED;
12928       }
12929
12930       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12931       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12932       drbItemIe->criticality = Criticality_reject;
12933       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12934       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12935       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12936       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12937       {
12938          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12939          return RFAILED;
12940       }
12941
12942    }
12943
12944    return ROK;
12945 }
12946 /*******************************************************************
12947 * @brief Free the memory allocated for DRB setup List
12948 *
12949 * @details
12950 *
12951 *    Function : FreeDrbSetupModList
12952 *
12953 *    Functionality:
12954 *       Free the memory allocated for DRB setup list
12955 *
12956 * @params[in] DRBs_Setup_List_t *
12957 * @return void
12958 *
12959 * ****************************************************************/
12960 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12961 {
12962    uint8_t arrIdx = 0;
12963    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12964
12965    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12966    {
12967       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12968       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12969       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12970    }
12971    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12972 }
12973 /*******************************************************************
12974 * @brief Free the memory allocated for UE Context Mod Response
12975 *
12976 * @details
12977 *
12978 *    Function : FreeUeContextModResp
12979 *
12980 *    Functionality:
12981 *       Free the memory allocated for UE Context Mod Response
12982 *
12983 * @params[in] F1AP_PDU_t *f1apMsg
12984 * @return void
12985 *
12986 * ****************************************************************/
12987
12988 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12989 {
12990    uint8_t ieIdx;
12991    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12992    if(f1apMsg)
12993    {
12994       if(f1apMsg->choice.successfulOutcome)
12995       {
12996          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12997          if(ueContextModifyRes->protocolIEs.list.array)
12998          {
12999             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
13000             {
13001                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
13002                {
13003                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
13004                   {
13005                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13006                         break;
13007                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13008                         break;
13009                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
13010                         {
13011                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
13012                             value.choice.DRBs_SetupMod_List));
13013                             break;
13014                         }
13015                   }
13016                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
13017                }
13018
13019             }
13020             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
13021          }
13022          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13023       }
13024       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13025    }
13026 }
13027
13028 /*****************************************************************i
13029 *
13030 * @brief Creating the ue context modifcation response and sending
13031 *
13032 * @details
13033 *
13034 *    Function : BuildAndSendUeContextModRsp
13035 *
13036 *    Functionality:
13037 *         - Creating the ue context modifcation response
13038 *
13039 * @params[in] uint8_t cellId,uint8_t ueId
13040 * @return ROK     - success
13041 *         RFAILED - failure
13042 *
13043 * ****************************************************************/
13044 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueId)
13045 {
13046    uint8_t   ieIdx = 0;
13047    uint8_t   cellIdx =0;
13048    uint8_t   elementCnt = 0;
13049    uint8_t   ret = RFAILED;
13050    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
13051    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
13052    F1AP_PDU_t *f1apMsg = NULLP;
13053    asn_enc_rval_t         encRetVal;
13054    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
13055    DuUeCb                   *ueCb = NULLP;
13056
13057    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
13058
13059    while(1)
13060    {
13061       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13062       if(f1apMsg == NULLP)
13063       {
13064          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
13065          break;
13066       }
13067
13068       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
13069
13070       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13071       if(f1apMsg->choice.successfulOutcome == NULLP)
13072       {
13073          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
13074          break;
13075       }
13076       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
13077       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13078       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
13079
13080       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
13081
13082       elementCnt = 3;
13083       ueContextModifyRes->protocolIEs.list.count = elementCnt;
13084       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
13085
13086       /* Initialize the UE context modification members */
13087       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
13088       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
13089       {
13090          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
13091          break;
13092       }
13093
13094       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
13095       {
13096          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
13097          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
13098          {
13099             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
13100             break;
13101          }
13102       }
13103
13104       /* Fetching Ue Cb Info*/
13105       GET_CELL_IDX(cellId, cellIdx);
13106       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
13107       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
13108       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
13109
13110       ieIdx=0;
13111       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13112       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
13113       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
13114       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
13115       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
13116
13117       ieIdx++;
13118       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13119       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
13120       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
13121       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
13122       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
13123
13124       ieIdx++;
13125       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
13126       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
13127       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
13128       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
13129       if(ueCb->f1UeDb)
13130       {
13131          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
13132                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
13133          if(ret != ROK)
13134          {
13135             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
13136             break;
13137          }
13138          freeF1UeDb(ueCb->f1UeDb);
13139          ueCb->f1UeDb = NULLP;
13140       }
13141       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13142
13143       /* Encode the F1SetupRequest type as APER */
13144       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13145       encBufSize = 0;
13146       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
13147
13148       /* Encode results */
13149       if(encRetVal.encoded == ENCODE_FAIL)
13150       {
13151          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
13152                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13153          ret = RFAILED;
13154          break;
13155       }
13156       else
13157       {
13158          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
13159          for(int i=0; i< encBufSize; i++)
13160          {
13161             printf("%x",encBuf[i]);
13162          }
13163       }
13164
13165       /* Sending  msg  */
13166       if(sendF1APMsg() != ROK)
13167       {
13168          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
13169          ret = RFAILED;
13170          break;
13171       }
13172       break;
13173    }
13174    FreeUeContextModResp(f1apMsg);
13175    return ret;
13176 }
13177 /*******************************************************************
13178  *
13179  * @brief Deallocating the memory allocated by the aper decoder
13180  *          for QOSInfo
13181  *
13182  * @details
13183  *
13184  *    Function : freeAperDecodeQosInfo
13185  *
13186  *    Functionality:  Deallocating the memory allocated for QOSInfo
13187  *
13188  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
13189  *
13190  * @return void
13191  *
13192  * ****************************************************************/
13193
13194 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
13195 {
13196    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
13197    {
13198       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
13199       {
13200          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
13201          {
13202             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
13203          }
13204          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
13205       }
13206       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
13207    }
13208 }
13209 /*******************************************************************
13210  *
13211  * @brief Deallocating the memory allocated by the aper decoder
13212  *          for UlTnlInfoforDrb
13213  *
13214  * @details
13215  *
13216  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
13217  *
13218  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
13219  *
13220  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
13221  *
13222  * @return void
13223  *
13224  * ****************************************************************/
13225 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
13226 {
13227    uint8_t arrIdx =0;
13228
13229    if(ulInfo->list.array)
13230    {
13231       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
13232       {
13233          if(ulInfo->list.array[arrIdx])
13234          {
13235             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
13236             {
13237                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
13238                {
13239                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
13240                   {
13241                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
13242                            gTP_TEID.buf);
13243                   }
13244                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
13245                         transportLayerAddress.buf);
13246                }
13247                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
13248             }
13249             free(ulInfo->list.array[arrIdx]);
13250          }
13251       }
13252       free(ulInfo->list.array);
13253    }
13254 }
13255 /*******************************************************************
13256  *
13257  * @brief Deallocating the memory allocated by the aper decoder
13258  *          for DrbSetupModItem
13259  *
13260  * @details
13261  *
13262  *    Function : freeAperDecodeDrbSetupModItem
13263  *
13264  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
13265  *
13266  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
13267  *
13268  * @return void
13269  *
13270  * ****************************************************************/
13271
13272 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
13273 {
13274    uint8_t arrIdx =0;
13275    SNSSAI_t *snssai =NULLP;
13276    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
13277
13278    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
13279    switch(drbItem->qoSInformation.present)
13280    {
13281       case QoSInformation_PR_NOTHING:
13282          break;
13283       case QoSInformation_PR_eUTRANQoS:
13284          {
13285             if(drbItem->qoSInformation.choice.eUTRANQoS)
13286             {
13287                free(drbItem->qoSInformation.choice.eUTRANQoS);
13288             }
13289             break;
13290          }
13291       case QoSInformation_PR_choice_extension:
13292          {
13293             if(drbItem->qoSInformation.choice.choice_extension)
13294             {
13295                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
13296                      DRB_Information.dRB_QoS);
13297                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
13298                if(snssai->sST.buf)
13299                {
13300                   free(snssai->sST.buf);
13301                }
13302                if(snssai->sD)
13303                {
13304                   if(snssai->sD->buf)
13305                   {
13306                      free(snssai->sD->buf);
13307                   }
13308                   free(snssai->sD);
13309                }
13310
13311                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
13312                          DRB_Information.flows_Mapped_To_DRB_List;
13313                if(flowMap->list.array)
13314                {
13315                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
13316                   {
13317                      if(flowMap->list.array[arrIdx] )
13318                      {
13319                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
13320                         free(flowMap->list.array[arrIdx]);
13321                      }
13322                   }
13323                   free(flowMap->list.array);
13324                }
13325
13326                free(drbItem->qoSInformation.choice.choice_extension);
13327             }
13328             break;
13329          }
13330
13331    }
13332    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
13333    if(drbItem->uLConfiguration)
13334    {
13335       free(drbItem->uLConfiguration);
13336    }
13337 }
13338
13339 /*******************************************************************
13340  *
13341  * @brief Deallocating the memory allocated by the aper decoder
13342  *          for DrbToBeSetupModList
13343  *
13344  * @details
13345  *
13346  *    Function : freeAperDecodeDrbToBeSetupModList
13347  *
13348  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
13349  *
13350  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
13351  *
13352  * @return void
13353  *
13354  * ****************************************************************/
13355
13356 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
13357 {
13358    uint8_t arrIdx =0;
13359    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
13360
13361    if(drbSet->list.array)
13362    {
13363       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
13364       {
13365          if(drbSet->list.array[arrIdx] != NULLP)
13366          {
13367             if(arrIdx == 0)
13368             {
13369                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
13370                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
13371             }
13372             free(drbSet->list.array[arrIdx]);
13373          }
13374       }
13375       free(drbSet->list.array);
13376    }
13377
13378 }
13379 /*******************************************************************
13380  *
13381  * @brief Deallocating the memory allocated by the aper decoder
13382  *          for UeContextModificationReqMsg
13383  *
13384  * @details
13385  *
13386  *    Function : freeAperDecodeUeContextModificationReqMsg
13387  *
13388  *    Functionality:  Deallocating memory allocated for
13389  *                  UeContextModificationReqMsg
13390  *
13391  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
13392  *
13393  * @return void
13394  *
13395  * ****************************************************************/
13396 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
13397 {
13398    uint8_t arrIdx, ieId;
13399
13400    if(UeContextModifyReq->protocolIEs.list.array)
13401    {
13402       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
13403       {
13404          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
13405          {
13406             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
13407             switch(ieId)
13408             {
13409                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13410                   break;
13411                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13412                   break;
13413                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
13414                   {
13415                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
13416                            value.choice.DRBs_ToBeSetupMod_List);
13417                      break;
13418                   }
13419             }
13420             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
13421          }
13422       }
13423       free(UeContextModifyReq->protocolIEs.list.array);
13424    }
13425 }
13426 /*******************************************************************
13427  *
13428  * @brief processing the F1 UeContextModificationReq
13429  *
13430  * @details
13431  *
13432  *    Function : procF1UeContextModificationReq
13433  *
13434  *    Functionality:  processing the F1 UeContextModificationReq
13435  *
13436  * @params[in] F1AP_PDU_t *f1apMsg
13437  *
13438  * @return
13439  * ****************************************************************/
13440 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
13441 {
13442    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
13443    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
13444    DuUeCb   *duUeCb = NULLP;
13445    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
13446    DRBs_ToBeModified_List_t *drbModifiedCfg;
13447    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
13448
13449    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
13450    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13451    {
13452       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
13453       {
13454          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13455             {
13456                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13457                break;
13458             }
13459          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13460             {
13461                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13462                break;
13463             }
13464          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
13465          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
13466             {
13467                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13468                {
13469                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13470                   {
13471                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13472                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13473                      {
13474
13475                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13476                         if(duUeCb->f1UeDb == NULLP)
13477                         {
13478                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13479                         }
13480                         if(duUeCb->f1UeDb)
13481                         {
13482                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
13483                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
13484                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
13485                            {
13486                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13487                               choice.DRBs_ToBeSetupMod_List;
13488
13489                               if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
13490                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
13491                               {
13492                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
13493                                  ret = RFAILED;
13494                               }
13495                            }
13496
13497                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
13498                                   UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
13499
13500                            {
13501                               drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13502                               choice.DRBs_ToBeModified_List;
13503                               if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
13504                                  &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
13505                               {
13506                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
13507                                  ret = RFAILED;
13508                               }
13509                            }
13510                         }
13511                         break;
13512                      }
13513                   }
13514                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
13515                   {
13516                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
13517                      ret = RFAILED;
13518                   }
13519                }
13520                break;
13521             }
13522       }
13523    }
13524    if(ret != RFAILED)
13525    {
13526       ret = duProcUeContextModReq(duUeCb);
13527    }
13528    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
13529    return ret;
13530 }
13531 /*****************************************************************i
13532 *
13533 * @brief Free memory allocated for UE Context Release Request
13534 *
13535 * @details
13536 *
13537 *    Function : FreeUeContextReleaseReq
13538 *
13539 *    Functionality:
13540 *         - Free memory allocated for UE Context Release Request
13541 *
13542 * @params[in] F1AP_PDU_t *f1apMsg
13543 * @return void
13544 *
13545 * *************************************************************/
13546 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
13547 {
13548    uint8_t ieIdx;
13549    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13550
13551    if(f1apMsg)
13552    {
13553       if(f1apMsg->choice.initiatingMessage)
13554       {
13555          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13556          if(ueReleaseReq->protocolIEs.list.array)
13557          {
13558             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
13559             {
13560                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
13561             }
13562             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
13563          }
13564          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13565       }
13566       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13567    }
13568
13569 }
13570 /*****************************************************************i
13571 *
13572 * @brief Build and Send UE Context Release Request
13573 *
13574 * @details
13575 *
13576 *    Function : BuildAndSendUeContextReleaseReq
13577 *
13578 *    Functionality:
13579 *         - Build and Send UE Context Release Request
13580 *
13581 * @params[in]
13582 * @return ROK     - success
13583 *         RFAILED - failure
13584 *
13585 * *************************************************************/
13586 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
13587 {
13588    bool memAllocFail = false;
13589    uint8_t ieIdx =0;
13590    uint8_t ret = RFAILED;
13591    uint16_t cellIdx =0;
13592    uint16_t crnti = 0;
13593    uint8_t  elementCnt = 0;
13594    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
13595    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
13596    asn_enc_rval_t encRetVal;
13597    F1AP_PDU_t *f1apMsg = NULLP;
13598    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13599
13600    DU_LOG("\nINFO  --> Building the UE Context Release Request");
13601    do
13602    {
13603       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13604       if(f1apMsg == NULLP)
13605       {
13606          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
13607          break;
13608       }
13609
13610       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13611       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13612       if(f1apMsg->choice.initiatingMessage == NULLP)
13613       {
13614          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
13615          initiatingMessage");
13616          break;
13617       }
13618       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
13619       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13620       f1apMsg->choice.initiatingMessage->value.present = \
13621       InitiatingMessage__value_PR_UEContextReleaseRequest;
13622
13623       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13624
13625       elementCnt = 2;
13626
13627       ueReleaseReq->protocolIEs.list.count = elementCnt;
13628       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
13629
13630       /* Initialize the F1Setup members */
13631       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13632       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13633       {
13634          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13635          break;
13636       }
13637       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13638       {
13639          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13640                sizeof(UEContextReleaseRequest_t));
13641          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13642          {
13643             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13644             memAllocFail = true;
13645             break;
13646          }
13647       }
13648       if(memAllocFail == true)
13649          break;
13650
13651       /* Fetching Ue Cb Info*/
13652       GET_CELL_IDX(cellId, cellIdx);
13653       if(duCb.actvCellLst[cellIdx] == NULLP)
13654       {
13655          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13656          break;
13657       }
13658       else
13659       {
13660          GET_CRNTI(crnti, ueId);
13661          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
13662          {
13663             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13664             break;
13665          }
13666          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
13667          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
13668       }
13669
13670       ieIdx=0;
13671       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13672       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13673       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13674       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13675       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13676
13677       ieIdx++;
13678       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13679       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13680       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13681       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13682       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13683
13684       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13685
13686       /* Encode the F1SetupRequest type as APER */
13687       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13688       encBufSize = 0;
13689       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13690       /* Encode results */
13691       if(encRetVal.encoded == ENCODE_FAIL)
13692       {
13693          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13694                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13695          break;
13696       }
13697       else
13698       {
13699          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13700          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13701          {
13702             printf("%x",encBuf[ieIdx]);
13703          }
13704       }
13705
13706       /* Sending msg */
13707       if(sendF1APMsg() != ROK)
13708       {
13709          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13710          break;
13711       }
13712       ret = ROK;
13713       break;
13714    }while(true);
13715
13716    FreeUeContextReleaseReq(f1apMsg);
13717    return ret;
13718 }
13719 /*****************************************************************i
13720  *
13721  * @brief Free memory allocated for UE Context Release Complete
13722  *
13723  * @details
13724  *
13725  *    Function : FreeUeContextReleaseComplete
13726  *
13727  *    Functionality:
13728  *         - Free memory allocated for UE Context Release Complete
13729  *
13730  * @params[in] F1AP_PDU_t *f1apMsg
13731  * @return void
13732  *
13733  * *************************************************************/
13734 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13735 {
13736    uint8_t ieIdx;
13737    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13738
13739    if(f1apMsg)
13740    {
13741       if(f1apMsg->choice.successfulOutcome)
13742       {
13743          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13744          if(ueReleaseComplete->protocolIEs.list.array)
13745          {
13746             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13747             {
13748                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13749             }
13750             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13751          }
13752          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13753       }
13754       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13755    }
13756
13757 }
13758 /*****************************************************************i
13759  *
13760  * @brief Build and Send UE Context Release Complete
13761  *
13762  * @details
13763  *
13764  *    Function : BuildAndSendUeContextReleaseComplete
13765  *
13766  *    Functionality:
13767  *         - Build and Send UE Context Release Complete
13768  *
13769  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13770  * @return ROK     - success
13771  *         RFAILED - failure
13772  *
13773  * *************************************************************/
13774 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13775 {
13776    bool memAllocFail = false;
13777    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13778    asn_enc_rval_t encRetVal;
13779    F1AP_PDU_t *f1apMsg = NULLP;
13780    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13781
13782    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13783    do
13784    {
13785       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13786       if(f1apMsg == NULLP)
13787       {
13788          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13789          break;
13790       }
13791
13792       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13793       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13794       if(f1apMsg->choice.successfulOutcome == NULLP)
13795       {
13796          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13797                successfulOutcome");
13798          break;
13799       }
13800       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13801       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13802       f1apMsg->choice.successfulOutcome->value.present = \
13803       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13804
13805       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13806
13807       elementCnt = 2;
13808       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13809       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13810
13811       /* Initialize the UE Release Complete members */
13812       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13813       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13814       {
13815          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13816          break;
13817       }
13818       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13819       {
13820          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13821                sizeof(UEContextReleaseComplete_t));
13822          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13823          {
13824             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13825             elements");
13826             memAllocFail = true;
13827             break;
13828          }
13829       }
13830       if(memAllocFail == true)
13831          break;
13832
13833
13834       ieIdx=0;
13835       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13836       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13837       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13838       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13839       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13840
13841       ieIdx++;
13842       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13843       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13844       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13845       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13846       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13847
13848       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13849
13850       /* Encode the F1SetupComplete type as APER */
13851       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13852       encBufSize = 0;
13853       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13854       /* Encode results */
13855       if(encRetVal.encoded == ENCODE_FAIL)
13856       {
13857          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13858                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13859          break;
13860       }
13861       else
13862       {
13863          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13864          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13865          {
13866             printf("%x",encBuf[ieIdx]);
13867          }
13868       }
13869
13870       /* Sending msg */
13871       if(sendF1APMsg() != ROK)
13872       {
13873          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13874          break;
13875       }
13876       ret = ROK;
13877       break;
13878    }while(true);
13879
13880    if(ret == ROK && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
13881    {
13882       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13883       ret = duSendCellDeletReq(cellId);
13884       if(ret != ROK)
13885       {
13886          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13887                Delete req for CellId");
13888       }
13889    }
13890    FreeUeContextReleaseComplete(f1apMsg);
13891    return ret;
13892
13893 }
13894
13895 /*******************************************************************
13896 *
13897 * @brief added free part for the memory allocated by aper_decoder
13898 *
13899 * @details
13900 *
13901 *    Function : freeAperDecodeUeContextReleaseCommand
13902 *
13903 *    Functionality: added free part for the memory allocated by aper_decoder
13904 *
13905 * @params[in] F1AP_PDU_t *f1apMsg
13906 * @return void
13907 *
13908 * ****************************************************************/
13909 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13910 {
13911    uint8_t ieIdx=0;
13912    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13913
13914    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13915
13916    if(ueContextReleaseCommand->protocolIEs.list.array)
13917    {
13918       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13919       {
13920          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13921          {
13922             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13923             {
13924                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13925                   break;
13926                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13927                   break;
13928                case ProtocolIE_ID_id_Cause:
13929                   break;
13930                case ProtocolIE_ID_id_RRCContainer:
13931                {
13932                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13933                   {
13934                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13935                   }
13936                   break;
13937                }
13938                default :
13939                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13940                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13941                   break;
13942             }
13943          }
13944          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13945       }
13946       free(ueContextReleaseCommand->protocolIEs.list.array);
13947    }
13948 }
13949 /*******************************************************************
13950 *
13951 * @brief processing of UE Context Release Command
13952 *
13953 * @details
13954 *
13955 *    Function : procF1UeContextReleaseCommand
13956 *
13957 *    Functionality: processing of UE Context Release Command
13958 *
13959 * @params[in] F1AP_PDU_t *f1apMsg
13960 * @return void
13961 *
13962 * ****************************************************************/
13963 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13964 {
13965    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13966    uint16_t cellIdx =0;
13967    bool ueIdxFound;
13968    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13969    DuUeCb   *duUeCb = NULLP;
13970    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13971
13972    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13973
13974    if(ueContextReleaseCommand->protocolIEs.list.array)
13975    {
13976       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13977       {
13978          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13979          {
13980             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13981             {
13982                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13983                   {
13984                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13985                                     value.choice.GNB_CU_UE_F1AP_ID;
13986                      break;
13987                   }
13988
13989                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13990                   {
13991                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13992                                      value.choice.GNB_DU_UE_F1AP_ID;
13993                      break;
13994                   }
13995
13996                case ProtocolIE_ID_id_Cause:
13997                   {
13998                      break;
13999                   }
14000
14001                case ProtocolIE_ID_id_RRCContainer:
14002                   {
14003                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
14004                      {
14005                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
14006                         {
14007                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
14008                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
14009                            {
14010                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
14011                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
14012                               if(duUeCb->f1UeDb)
14013                               {
14014                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
14015                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
14016                                  duUeCb->f1UeDb->cellIdx = cellIdx;
14017                                  /* Filling Dl RRC Msg Info */
14018                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
14019                                  if(!duUeCb->f1UeDb->dlRrcMsg)
14020                                  {
14021                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
14022                                     Memory allocation failed ");
14023                                     ret = RFAILED;
14024                                  }
14025                                  else
14026                                  {
14027                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
14028                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
14029                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
14030                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
14031                                           value.choice.RRCContainer);
14032                                  }
14033
14034                               }
14035                               else
14036                               {
14037                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
14038                                  Memory allocation failed ");
14039                                  ret = RFAILED;
14040
14041                               }
14042
14043                               ueIdxFound = true;
14044                               break;
14045                            }
14046                         }
14047                         if(ueIdxFound == true)
14048                         {
14049                            break;
14050                         }
14051                      }
14052                      if(!ueIdxFound)
14053                      {
14054                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextReleaseCommand()");
14055                         ret = RFAILED;
14056                      }
14057
14058
14059                      break;
14060                   }
14061                default :
14062                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
14063                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
14064                   break;
14065             }
14066          }
14067       }
14068    }
14069    if(ret != RFAILED)
14070    {
14071       duProcUeContextReleaseCommand(duUeCb);
14072    }
14073    freeAperDecodeUeContextReleaseCommand(f1apMsg);
14074    return ret;
14075 }
14076 /**************************************************************
14077  *
14078  * @brief Handles received F1AP message and sends back response
14079  *
14080  * @details
14081  *
14082  *    Function : F1APMsgHdlr
14083  *
14084  *    Functionality:
14085  *         - Decodes received F1AP control message
14086  *         - Prepares response message, encodes and sends to SCTP
14087  *
14088  * @params[in]
14089  * @return ROK     - success
14090  *         RFAILED - failure
14091  *
14092  * ****************************************************************/
14093 void F1APMsgHdlr(Buffer *mBuf)
14094 {
14095    int i =0;
14096    char *recvBuf =NULLP;
14097    MsgLen copyCnt =0;
14098    MsgLen recvBufLen =0;
14099    F1AP_PDU_t *f1apMsg =NULLP;
14100    asn_dec_rval_t rval; /* Decoder return value */
14101    F1AP_PDU_t f1apasnmsg ;
14102    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
14103    ODU_PRINT_MSG(mBuf, 0,0);
14104
14105    /* Copy mBuf into char array to decode it */
14106    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
14107    DU_ALLOC(recvBuf, (Size)recvBufLen);
14108
14109    if(recvBuf == NULLP)
14110    {
14111       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
14112       return;
14113    }
14114    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
14115    {
14116       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
14117       return;
14118    }
14119
14120    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
14121    for(i=0; i< recvBufLen; i++)
14122    {
14123       printf("%x",recvBuf[i]);
14124    }
14125
14126    /* Decoding flat buffer into F1AP messsage */
14127    f1apMsg = &f1apasnmsg;
14128    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
14129
14130    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
14131    DU_FREE(recvBuf, (Size)recvBufLen);
14132
14133    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
14134    {
14135       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
14136       return;
14137    }
14138    printf("\n");
14139    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14140
14141    switch(f1apMsg->present)
14142    {
14143       case F1AP_PDU_PR_successfulOutcome:
14144          {
14145             switch(f1apMsg->choice.successfulOutcome->value.present)
14146             {
14147                case SuccessfulOutcome__value_PR_ResetAcknowledge:
14148                   {
14149                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
14150                      break;
14151                   }
14152                case SuccessfulOutcome__value_PR_F1SetupResponse:
14153                   {
14154 #ifndef ODU_TEST_STUB
14155                      procF1SetupRsp(f1apMsg);
14156 #endif
14157                      break;
14158                   }
14159
14160                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
14161                   {
14162                      procF1GNBDUCfgUpdAck(f1apMsg);
14163                      break;
14164                   }
14165
14166                default:
14167                   {
14168                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
14169                            f1apMsg->choice.successfulOutcome->value.present);
14170                      return;
14171                   }
14172             }/* End of switch(successfulOutcome) */
14173             free(f1apMsg->choice.successfulOutcome);
14174             break;
14175          }
14176       case F1AP_PDU_PR_initiatingMessage:
14177          {
14178             switch(f1apMsg->choice.initiatingMessage->value.present)
14179             {
14180                case InitiatingMessage__value_PR_Reset:
14181                   {
14182                      procF1ResetReq(f1apMsg);
14183                      break;
14184                   }
14185                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
14186                   {
14187                      procF1DlRrcMsgTrans(f1apMsg);
14188                      break;
14189                   }
14190                case InitiatingMessage__value_PR_UEContextSetupRequest:
14191                   {
14192                      procF1UeContextSetupReq(f1apMsg);
14193                      break;
14194                   }
14195                case InitiatingMessage__value_PR_UEContextModificationRequest:
14196                   {
14197                      procF1UeContextModificationReq(f1apMsg);
14198                      break;
14199                   }
14200                case InitiatingMessage__value_PR_UEContextReleaseCommand:
14201                   {
14202                       procF1UeContextReleaseCommand(f1apMsg);
14203                       break;
14204                   }
14205                default:
14206                   {
14207                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
14208                            f1apMsg->choice.initiatingMessage->value.present);
14209                      return;
14210                   }
14211             }/* End of switch(initiatingMessage) */
14212             free(f1apMsg->choice.initiatingMessage);
14213             break;
14214          }
14215
14216       default:
14217          {
14218             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
14219             return;
14220          }
14221          free(f1apMsg);
14222
14223    }/* End of switch(f1apMsg->present) */
14224
14225 } /* End of F1APMsgHdlr */
14226
14227 /**********************************************************************
14228   End of file
14229  **********************************************************************/